Bump to 0.182.8 for @bennetbo

Cherry-picked gemini: Fix "invalid argument" error when request contains
no tools (#28747)

When we do not have any tools, we want to set the `tools` field to
`None`

Release Notes:

- Fixed an issue where Gemini requests would sometimes return a Bad
Request ("Invalid argument...")

Co-authored-by: Bennet Bo Fenner <bennet@zed.dev>

.config/hakari.toml

@@ -0,0 +1,43 @@
+# This file contains settings for `cargo hakari`.
+# See https://docs.rs/cargo-hakari/latest/cargo_hakari/config for a full list of options.
+
+hakari-package = "workspace-hack"
+
+resolver = "2"
+dep-format-version = "4"
+workspace-hack-line-style = "workspace-dotted"
+
+# this should be the same list as "targets" in ../rust-toolchain.toml
+platforms = [
+    "x86_64-apple-darwin",
+    "aarch64-apple-darwin",
+    "x86_64-unknown-linux-gnu",
+    "aarch64-unknown-linux-gnu",
+    "x86_64-pc-windows-msvc",
+    "x86_64-unknown-linux-musl", # remote server
+]
+
+[traversal-excludes]
+workspace-members = [
+    "remote_server",
+]
+third-party = [
+    { name = "reqwest", version = "0.11.27" },
+]
+
+[final-excludes]
+workspace-members = [
+    "zed_extension_api",
+
+    # exclude all extensions
+    "zed_emmet",
+    "zed_glsl",
+    "zed_html",
+    "perplexity",
+    "zed_proto",
+    "zed_ruff",
+    "slash_commands_example",
+    "zed_snippets",
+    "zed_test_extension",
+    "zed_toml",
+]

.github/ISSUE_TEMPLATE/01_bug_agent.yml

@@ -0,0 +1,36 @@
+name: Bug Report (Agent Panel)
+description: Zed Agent Panel Bugs
+type: "Bug"
+labels: ["agent", "ai"]
+title: "Agent Panel: <a short description of the Agent Panel 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

.github/ISSUE_TEMPLATE/02_bug_edit_predictions.yml

@@ -0,0 +1,36 @@
+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

.github/ISSUE_TEMPLATE/03_bug_git.yml

@@ -0,0 +1,35 @@
+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

.github/ISSUE_TEMPLATE/10_bug_report.yml

@@ -0,0 +1,56 @@
+name: Bug Report (Other)
+description: |
+  Something else is broken in Zed (exclude crashing).
+type: "Bug"
+body:
+  - type: textarea
+    attributes:
+      label: Summary
+      description: Provide a one sentence summary and detailed reproduction steps
+      value: |
+        <!-- Begin your issue with a one sentence summary -->
+        SUMMARY_SENTENCE_HERE
+
+        ### Description
+        <!--  Describe with sufficient detail to reproduce from a clean Zed install.
+          - Any code must be sufficient to reproduce (include context!)
+          - Code must as text, not just as a screenshot.
+          - Issues with insufficient detail may be summarily closed.
+        -->
+
+        Steps to reproduce:
+        1.
+        2.
+        3.
+        4.
+
+        Expected Behavior:
+        Actual Behavior:
+
+        <!-- Before Submitting, did you:
+          1. Include settings.json, keymap.json, .editorconfig if relevant?
+          2. Check your Zed.log for relevant errors? (please include!)
+          3. Click Preview to ensure everything looks right?
+          4. Hide videos, large images and logs in ``` inside collapsible blocks:
+
+        <details><summary>click to expand</summary>
+
+        ```json
+
+        ```
+        </details>
+        -->
+
+    validations:
+      required: true
+
+  - type: textarea
+    id: environment
+    attributes:
+      label: Zed Version and System Specs
+      description: |
+        Open Zed, from the command palette select "zed: Copy System Specs Into Clipboard"
+      placeholder: |
+        Output of "zed: Copy System Specs Into Clipboard"
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/11_crash_report.yml

@@ -5,10 +5,12 @@ body:
   - type: textarea
     attributes:
       label: Summary
-      description: Describe the bug with a one line summary, and provide detailed reproduction steps
+      description: Summarize the issue with detailed reproduction steps
       value: |
-        <!-- Please insert a one line summary of the issue below -->
+        <!-- Begin your issue with a one sentence summary -->
+        SUMMARY_SENTENCE_HERE
 
+        ### Description
         <!-- Include all steps necessary to reproduce from a clean Zed installation. Be verbose -->
         Steps to trigger the problem:
         1.
@@ -16,7 +18,6 @@ body:
         3.
 
         Actual Behavior:
-
         Expected Behavior:
 
     validations:
@@ -40,10 +41,11 @@ body:
       value: |
         <details><summary>Zed.log</summary>
 
-        <!-- Click below this line and paste or drag-and-drop your log-->
-        ```
+        <!-- Paste your log inside the code block. -->
+        ```log
 
         ```
-        <!-- Click above this line and paste or drag-and-drop your log--></details>
+
+        </details>
     validations:
       required: false

.github/ISSUE_TEMPLATE/1_bug_report.yml

@@ -1,57 +0,0 @@
-name: Bug Report
-description: |
-  Something is broken in Zed (exclude crashing).
-type: "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
-
-        <!-- Be verbose: Include all steps necessary to reproduce from a clean Zed installation. -->
-        <!-- Code snippets are better than images, a repository link that reproduces the issue is ideal. -->
-
-        Steps to trigger the problem:
-        1.
-        2.
-        3.
-        4.
-
-        Actual Behavior:
-
-        Expected Behavior:
-
-        <!--
-          Is there anything additional necessary to reproduce this issue?
-            - settings.json, keymap.json, .editorconfig etc?
-            - Does it happen intermittently or only with specific projects / file types?
-            - Have you found a workaround?
-
-          Did you check your Zed.log to see if there is any relevant details there?
-            - When including large items (videos, screenshots, logs, configs) please wrap with:
-
-          <details><summary>See inside for XXXXYYY</summary>
-
-          ```shell
-          code
-          ```
-
-          </details>
-        -->
-
-    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

.github/ISSUE_TEMPLATE/config.yml

@@ -4,9 +4,6 @@ contact_links:
   - name: Feature Request
     url: https://github.com/zed-industries/zed/discussions/new/choose
     about: To request a feature, open a new Discussion in one of the appropriate Discussion categories
-  - name: Zed Discussion Forum
-    url: https://github.com/zed-industries/zed/discussions
-    about: A community discussion forum
-  - name: "Zed Discord: #Support Channel"
+  - name: "Zed Discord"
     url: https://zed.dev/community-links
     about: Real-time discussion and user support

.github/actions/run_tests_windows/action.yml

@@ -23,4 +23,4 @@ runs:
     - name: Run tests
       shell: pwsh
       working-directory: ${{ inputs.working-directory }}
-      run: cargo nextest run --workspace --no-fail-fast
+      run: cargo nextest run --workspace --no-fail-fast --config='profile.dev.debug="limited"'

.github/workflows/ci.yml

@@ -110,6 +110,39 @@ jobs:
           input: "crates/proto/proto/"
           against: "https://github.com/${GITHUB_REPOSITORY}.git#branch=${BUF_BASE_BRANCH},subdir=crates/proto/proto/"
 
+  workspace_hack:
+    timeout-minutes: 60
+    name: Check workspace-hack crate
+    needs: [job_spec]
+    if: |
+      github.repository_owner == 'zed-industries' &&
+      needs.job_spec.outputs.run_tests == 'true'
+    runs-on:
+      - buildjet-8vcpu-ubuntu-2204
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - name: Add Rust to the PATH
+        run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH
+      - name: Install cargo-hakari
+        uses: clechasseur/rs-cargo@8435b10f6e71c2e3d4d3b7573003a8ce4bfc6386 # v2
+        with:
+          command: install
+          args: cargo-hakari@0.9.35
+
+      - name: Check workspace-hack Cargo.toml is up-to-date
+        run: |
+          cargo hakari generate --diff || {
+            echo "To fix, run script/update-workspace-hack or script/update-workspace-hack.ps1";
+            false
+          }
+      - name: Check all crates depend on workspace-hack
+        run: |
+          cargo hakari manage-deps --dry-run || {
+            echo "To fix, run script/update-workspace-hack or script/update-workspace-hack.ps1"
+            false
+          }
+
   style:
     timeout-minutes: 60
     name: Check formatting and spelling
@@ -432,6 +465,7 @@ jobs:
       - job_spec
       - style
       - migration_checks
+      - workspace_hack
       - linux_tests
       - build_remote_server
       - macos_tests
@@ -674,6 +708,51 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
+  nix-build:
+    timeout-minutes: 60
+    name: Nix Build
+    continue-on-error: true
+    if: github.repository_owner == 'zed-industries' && contains(github.event.pull_request.labels.*.name, 'run-nix')
+    strategy:
+      fail-fast: false
+      matrix:
+        system:
+          - os: x86 Linux
+            runner: buildjet-16vcpu-ubuntu-2204
+            install_nix: true
+          - os: arm Mac
+            runner: [macOS, ARM64, test]
+            install_nix: false
+    runs-on: ${{ matrix.system.runner }}
+    env:
+      ZED_CLIENT_CHECKSUM_SEED: ${{ secrets.ZED_CLIENT_CHECKSUM_SEED }}
+      ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON: ${{ secrets.ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON }}
+      GIT_LFS_SKIP_SMUDGE: 1 # breaks the livekit rust sdk examples which we don't actually depend on
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        with:
+          clean: false
+      - name: Set path
+        if: ${{ ! matrix.system.install_nix }}
+        run: |
+          echo "/nix/var/nix/profiles/default/bin" >> $GITHUB_PATH
+          echo "/Users/administrator/.nix-profile/bin" >> $GITHUB_PATH
+
+      - uses: cachix/install-nix-action@02a151ada4993995686f9ed4f1be7cfbb229e56f # v31
+        if: ${{ matrix.system.install_nix }}
+        with:
+          github_access_token: ${{ secrets.GITHUB_TOKEN }}
+
+      - uses: cachix/cachix-action@0fc020193b5a1fa3ac4575aa3a7d3aa6a35435ad # v16
+        with:
+          name: zed-industries
+          authToken: "${{ secrets.CACHIX_AUTH_TOKEN }}"
+          skipPush: true
+      - run: nix build .#debug
+      - name: Limit /nix/store to 50GB
+        run: "[ $(du -sm /nix/store | cut -f1) -gt 50000 ] && nix-collect-garbage -d"
+
   auto-release-preview:
     name: Auto release preview
     if: |

.github/workflows/release_nightly.yml

@@ -216,7 +216,8 @@ jobs:
           name: zed-industries
           authToken: "${{ secrets.CACHIX_AUTH_TOKEN }}"
       - run: nix build
-      - run: nix-collect-garbage -d
+      - name: Limit /nix/store to 50GB
+        run: '[ $(du -sm /nix/store | cut -f1) -gt 50000 ] && nix-collect-garbage -d'
 
   update-nightly-tag:
     name: Update nightly tag

.zed/debug.json

@@ -1,14 +1,14 @@
 [
   {
     "label": "Debug Zed with LLDB",
-    "adapter": "lldb",
+    "adapter": "LLDB",
     "program": "$ZED_WORKTREE_ROOT/target/debug/zed",
     "request": "launch",
     "cwd": "$ZED_WORKTREE_ROOT"
   },
   {
     "label": "Debug Zed with GDB",
-    "adapter": "gdb",
+    "adapter": "GDB",
     "program": "$ZED_WORKTREE_ROOT/target/debug/zed",
     "request": "launch",
     "cwd": "$ZED_WORKTREE_ROOT",

Cargo.toml

@@ -8,7 +8,6 @@ members = [
     "crates/assets",
     "crates/assistant",
     "crates/assistant_context_editor",
-    "crates/assistant_eval",
     "crates/assistant_settings",
     "crates/assistant_slash_command",
     "crates/assistant_slash_commands",
@@ -46,6 +45,7 @@ members = [
     "crates/diagnostics",
     "crates/docs_preprocessor",
     "crates/editor",
+    "crates/eval",
     "crates/evals",
     "crates/extension",
     "crates/extension_api",
@@ -192,6 +192,7 @@ members = [
     # Tooling
     #
 
+    "tooling/workspace-hack",
     "tooling/xtask",
 ]
 default-members = ["crates/zed"]
@@ -214,7 +215,6 @@ askpass = { path = "crates/askpass" }
 assets = { path = "crates/assets" }
 assistant = { path = "crates/assistant" }
 assistant_context_editor = { path = "crates/assistant_context_editor" }
-assistant_eval = { path = "crates/assistant_eval" }
 assistant_settings = { path = "crates/assistant_settings" }
 assistant_slash_command = { path = "crates/assistant_slash_command" }
 assistant_slash_commands = { path = "crates/assistant_slash_commands" }
@@ -395,14 +395,14 @@ async-pipe = { git = "https://github.com/zed-industries/async-pipe-rs", rev = "8
 async-recursion = "1.0.0"
 async-tar = "0.5.0"
 async-trait = "0.1"
-async-tungstenite = "0.28"
+async-tungstenite = "0.29.1"
 async-watch = "0.3.1"
 async_zip = { version = "0.0.17", features = ["deflate", "deflate64"] }
-aws-config = { version = "1.5.16", features = ["behavior-version-latest"] }
-aws-credential-types = { version = "1.2.1", features = ["hardcoded-credentials"] }
-aws-sdk-bedrockruntime = { version = "1.73.0", features = ["behavior-version-latest"] }
-aws-smithy-runtime-api = { version = "1.7.3", features = ["http-1x", "client"] }
-aws-smithy-types = { version = "1.2.13", features = ["http-body-1-x"] }
+aws-config = { version = "1.6.1", features = ["behavior-version-latest"] }
+aws-credential-types = { version = "1.2.2", features = ["hardcoded-credentials"] }
+aws-sdk-bedrockruntime = { version = "1.80.0", features = ["behavior-version-latest"] }
+aws-smithy-runtime-api = { version = "1.7.4", features = ["http-1x", "client"] }
+aws-smithy-types = { version = "1.3.0", features = ["http-body-1-x"] }
 base64 = "0.22"
 bitflags = "2.6.0"
 blade-graphics = { git = "https://github.com/kvark/blade", rev = "b16f5c7bd873c7126f48c82c39e7ae64602ae74f" }
@@ -424,7 +424,7 @@ core-foundation = "0.10.0"
 core-foundation-sys = "0.8.6"
 ctor = "0.4.0"
 dashmap = "6.0"
-dap-types = { git = "https://github.com/zed-industries/dap-types", rev = "bfd4af0" }
+dap-types = { git = "https://github.com/zed-industries/dap-types", rev = "be69a016ba710191b9fdded28c8b042af4b617f7" }
 derive_more = "0.99.17"
 dirs = "4.0"
 ec4rs = "1.1"
@@ -452,8 +452,8 @@ indoc = "2"
 inventory = "0.3.19"
 itertools = "0.14.0"
 jsonwebtoken = "9.3"
-jupyter-protocol = { version = "0.6.0" }
-jupyter-websocket-client = { version = "0.9.0" }
+jupyter-protocol = { git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734" }
+jupyter-websocket-client = {  git = "https://github.com/ConradIrwin/runtimed" ,rev = "7130c804216b6914355d15d0b91ea91f6babd734" }
 libc = "0.2"
 libsqlite3-sys = { version = "0.30.1", features = ["bundled"] }
 linkify = "0.10.0"
@@ -462,21 +462,22 @@ log = { version = "0.4.16", features = ["kv_unstable_serde", "serde"] }
 markup5ever_rcdom = "0.3.0"
 mlua = { version = "0.10", features = ["lua54", "vendored", "async", "send"] }
 nanoid = "0.4"
-nbformat = { version = "0.10.0" }
+nbformat = {  git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734" }
 nix = "0.29"
+objc = "0.2"
 open = "5.0.0"
 num-format = "0.4.4"
 ordered-float = "2.1.1"
 palette = { version = "0.7.5", default-features = false, features = ["std"] }
 parking_lot = "0.12.1"
 pathdiff = "0.2"
-pet = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "1abe5cec5ebfbe97ca71746a4cfc7fe89bddf8e0" }
-pet-fs = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "1abe5cec5ebfbe97ca71746a4cfc7fe89bddf8e0" }
-pet-pixi = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "1abe5cec5ebfbe97ca71746a4cfc7fe89bddf8e0" }
-pet-conda = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "1abe5cec5ebfbe97ca71746a4cfc7fe89bddf8e0" }
-pet-core = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "1abe5cec5ebfbe97ca71746a4cfc7fe89bddf8e0" }
-pet-poetry = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "1abe5cec5ebfbe97ca71746a4cfc7fe89bddf8e0" }
-pet-reporter = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "1abe5cec5ebfbe97ca71746a4cfc7fe89bddf8e0" }
+pet = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "845945b830297a50de0e24020b980a65e4820559" }
+pet-fs = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "845945b830297a50de0e24020b980a65e4820559" }
+pet-pixi = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "845945b830297a50de0e24020b980a65e4820559" }
+pet-conda = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "845945b830297a50de0e24020b980a65e4820559" }
+pet-core = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "845945b830297a50de0e24020b980a65e4820559" }
+pet-poetry = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "845945b830297a50de0e24020b980a65e4820559" }
+pet-reporter = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "845945b830297a50de0e24020b980a65e4820559" }
 postage = { version = "0.5", features = ["futures-traits"] }
 pretty_assertions = { version = "1.3.0", features = ["unstable"] }
 proc-macro2 = "1.0.93"
@@ -499,14 +500,15 @@ reqwest = { git = "https://github.com/zed-industries/reqwest.git", rev = "fd110f
     "stream",
 ] }
 rsa = "0.9.6"
-runtimelib = { version = "0.25.0", default-features = false, features = [
+runtimelib = {  git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734", default-features = false, features = [
     "async-dispatcher-runtime",
 ] }
 rustc-demangle = "0.1.23"
 rust-embed = { version = "8.4", features = ["include-exclude"] }
 rustc-hash = "2.1.0"
-rustls = { version = "0.23.22" }
+rustls = { version = "0.23.26" }
 rustls-platform-verifier = "0.5.0"
+scap = { git = "https://github.com/zed-industries/scap", rev = "08f0a01417505cc0990b9931a37e5120db92e0d0", default-features = false }
 schemars = { version = "0.8", features = ["impl_json_schema", "indexmap2"] }
 semver = "1.0"
 serde = { version = "1.0", features = ["derive", "rc"] }
@@ -546,7 +548,7 @@ time = { version = "0.3", features = [
 tiny_http = "0.8"
 toml = "0.8"
 tokio = { version = "1" }
-tokio-tungstenite = { version = "0.26", features = ["__rustls-tls"]}
+tokio-tungstenite = { version = "0.26", features = ["__rustls-tls"] }
 tower-http = "0.4.4"
 tree-sitter = { version = "0.25.3", features = ["wasm"] }
 tree-sitter-bash = "0.23"
@@ -578,6 +580,7 @@ unicode-script = "0.5.7"
 url = "2.2"
 urlencoding = "2.1.2"
 uuid = { version = "1.1.2", features = ["v4", "v5", "v7", "serde"] }
+walkdir = "2.3"
 wasmparser = "0.221"
 wasm-encoder = "0.221"
 wasmtime = { version = "29", default-features = false, features = [
@@ -590,6 +593,7 @@ wasmtime = { version = "29", default-features = false, features = [
 wasmtime-wasi = "29"
 which = "6.0.0"
 wit-component = "0.221"
+workspace-hack = "0.1.0"
 zed_llm_client = "0.4"
 zstd = "0.11"
 metal = "0.29"
@@ -656,13 +660,14 @@ features = [
 # TODO livekit https://github.com/RustAudio/cpal/pull/891
 [patch.crates-io]
 cpal = { git = "https://github.com/zed-industries/cpal", rev = "fd8bc2fd39f1f5fdee5a0690656caff9a26d9d50" }
-real-async-tls = { git = "https://github.com/zed-industries/async-tls", rev = "1e759a4b5e370f87dc15e40756ac4f8815b61d9d", package = "async-tls" }
 notify = { git = "https://github.com/zed-industries/notify.git", rev = "bbb9ea5ae52b253e095737847e367c30653a2e96" }
 notify-types = { git = "https://github.com/zed-industries/notify.git", rev = "bbb9ea5ae52b253e095737847e367c30653a2e96" }
 
+# Makes the workspace hack crate refer to the local one, but only when you're building locally
+workspace-hack = { path = "tooling/workspace-hack" }
+
 [profile.dev]
 split-debuginfo = "unpacked"
-debug = "limited"
 codegen-units = 16
 
 [profile.dev.package]
@@ -772,4 +777,4 @@ let_underscore_future = "allow"
 too_many_arguments = "allow"
 
 [workspace.metadata.cargo-machete]
-ignored = ["bindgen", "cbindgen", "prost_build", "serde", "component", "linkme"]
+ignored = ["bindgen", "cbindgen", "prost_build", "serde", "component", "linkme", "workspace-hack"]

Dockerfile-collab

@@ -1,6 +1,6 @@
 # syntax = docker/dockerfile:1.2
 
-FROM rust:1.81-bookworm as builder
+FROM rust:1.86-bookworm as builder
 WORKDIR app
 COPY . .
 

assets/icons/ai_anthropic_hosted.svg

@@ -1,12 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<rect width="16" height="16" rx="2" fill="black" fill-opacity="0.2"/>
-<g clip-path="url(#clip0_1916_18)">
-<path d="M10.652 3.79999H8.816L12.164 12.2H14L10.652 3.79999Z" fill="#1F1F1E"/>
-<path d="M5.348 3.79999L2 12.2H3.872L4.55672 10.436H8.05927L8.744 12.2H10.616L7.268 3.79999H5.348ZM5.16224 8.87599L6.308 5.92399L7.45374 8.87599H5.16224Z" fill="#1F1F1E"/>
-</g>
-<defs>
-<clipPath id="clip0_1916_18">
-<rect width="12" height="8.4" fill="white" transform="translate(2 3.79999)"/>
-</clipPath>
-</defs>
-</svg>

assets/icons/arrow_down_right.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-arrow-down-right-icon lucide-arrow-down-right"><path d="m7 7 10 10"/><path d="M17 7v10H7"/></svg>

assets/icons/arrow_up_right.svg

@@ -1,3 +1 @@
-<svg width="8" height="8" viewBox="0 0 8 8" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M6 2H6.5C6.5 1.86739 6.44732 1.74021 6.35355 1.64645C6.25979 1.55268 6.13261 1.5 6 1.5V2ZM2 1.5C1.72386 1.5 1.5 1.72386 1.5 2C1.5 2.27614 1.72386 2.5 2 2.5L2 1.5ZM5.5 6C5.5 6.27614 5.72386 6.5 6 6.5C6.27614 6.5 6.5 6.27614 6.5 6H5.5ZM1.64645 5.64645C1.45118 5.84171 1.45118 6.15829 1.64645 6.35355C1.84171 6.54882 2.15829 6.54882 2.35355 6.35355L1.64645 5.64645ZM6 1.5H2L2 2.5H6V1.5ZM5.5 2V6H6.5V2H5.5ZM5.64645 1.64645L1.64645 5.64645L2.35355 6.35355L6.35355 2.35355L5.64645 1.64645Z" fill="white"/>
-</svg>
+<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-arrow-up-right-icon lucide-arrow-up-right"><path d="M7 7h10v10"/><path d="M7 17 17 7"/></svg>

assets/icons/bug_off.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-bug-off-icon lucide-bug-off"><path d="M15 7.13V6a3 3 0 0 0-5.14-2.1L8 2"/><path d="M14.12 3.88 16 2"/><path d="M22 13h-4v-2a4 4 0 0 0-4-4h-1.3"/><path d="M20.97 5c0 2.1-1.6 3.8-3.5 4"/><path d="m2 2 20 20"/><path d="M7.7 7.7A4 4 0 0 0 6 11v3a6 6 0 0 0 11.13 3.13"/><path d="M12 20v-8"/><path d="M6 13H2"/><path d="M3 21c0-2.1 1.7-3.9 3.8-4"/></svg>

assets/icons/circle_off.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-off-icon lucide-circle-off"><path d="m2 2 20 20"/><path d="M8.35 2.69A10 10 0 0 1 21.3 15.65"/><path d="M19.08 19.08A10 10 0 1 1 4.92 4.92"/></svg>

assets/icons/forward_arrow.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-forward-icon lucide-forward"><polyline points="15 17 20 12 15 7"/><path d="M4 18v-2a4 4 0 0 1 4-4h12"/></svg>

assets/icons/light_bulb.svg

@@ -0,0 +1,3 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M10.1331 11.3776C10.2754 10.6665 10.1331 9.78593 11.1998 8.53327C11.82 7.80489 12.2664 6.96894 12.2664 6.04456C12.2664 4.91305 11.8169 3.82788 11.0168 3.02778C10.2167 2.22769 9.13152 1.7782 8.00001 1.7782C6.8685 1.7782 5.78334 2.22769 4.98324 3.02778C4.18314 3.82788 3.73364 4.91305 3.73364 6.04456C3.73364 6.75562 3.87586 7.6089 4.80024 8.53327C5.86683 9.80679 5.72462 10.6665 5.86683 11.3776M10.1331 11.3776V12.8821C10.1331 13.622 9.53341 14.2218 8.79353 14.2218H7.2065C6.46662 14.2218 5.86683 13.622 5.86683 12.8821V11.3776M10.1331 11.3776H5.86683" stroke="black" stroke-width="1.33333" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

assets/icons/power.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-power-icon lucide-power"><path d="M12 2v10"/><path d="M18.4 6.6a9 9 0 1 1-12.77.04"/></svg>

assets/icons/send.svg

@@ -0,0 +1,4 @@
+<svg width="14" height="14" viewBox="0 0 14 14" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M3.09666 3.02263C3.0567 3.00312 3.01178 2.9961 2.96778 3.0025C2.92377 3.00889 2.88271 3.02839 2.84995 3.05847C2.8172 3.08854 2.79426 3.12778 2.78413 3.17108C2.77401 3.21439 2.77716 3.25973 2.79319 3.30121L4.05638 6.69C4.13088 6.89005 4.13088 7.11022 4.05638 7.31027L2.79363 10.6991C2.77769 10.7405 2.77457 10.7858 2.78469 10.829C2.79481 10.8722 2.8177 10.9114 2.85038 10.9414C2.88306 10.9715 2.92402 10.991 2.96794 10.9975C3.01186 11.0039 3.05671 10.997 3.09666 10.9776L11.0943 7.20097C11.1324 7.18297 11.1645 7.15455 11.187 7.11899C11.2096 7.08344 11.2215 7.04222 11.2215 7.00014C11.2215 6.95805 11.2096 6.91683 11.187 6.88128C11.1645 6.84573 11.1324 6.8173 11.0943 6.79931L3.09666 3.02263Z" stroke="black" stroke-width="1.33333" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M4.11255 7.00014H11.2216" stroke="black" stroke-width="1.33333" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

assets/icons/stop_filled.svg

@@ -0,0 +1,3 @@
+<svg width="14" height="14" viewBox="0 0 14 14" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M4 9.8V4.2C4 4.08954 4.08954 4 4.2 4H9.8C9.91046 4 10 4.08954 10 4.2V9.8C10 9.91046 9.91046 10 9.8 10H4.2C4.08954 10 4 9.91046 4 9.8Z" fill="#C56757" stroke="#C56757" stroke-width="1.25" stroke-linejoin="round"/>
+</svg>

assets/keymaps/default-linux.json

@@ -150,7 +150,9 @@
     "context": "AgentDiff",
     "bindings": {
       "ctrl-y": "agent::Keep",
-      "ctrl-k ctrl-r": "agent::Reject"
+      "ctrl-n": "agent::Reject",
+      "ctrl-shift-y": "agent::KeepAll",
+      "ctrl-shift-n": "agent::RejectAll"
     }
   },
   {
@@ -311,6 +313,7 @@
       "ctrl-k t": ["pane::CloseItemsToTheRight", { "close_pinned": false }],
       "ctrl-k u": ["pane::CloseCleanItems", { "close_pinned": false }],
       "ctrl-k w": ["pane::CloseAllItems", { "close_pinned": false }],
+      "ctrl-k ctrl-w": "workspace::CloseAllItemsAndPanes",
       "back": "pane::GoBack",
       "ctrl-alt--": "pane::GoBack",
       "ctrl-alt-_": "pane::GoForward",
@@ -481,6 +484,8 @@
       "alt-shift-r": ["task::Spawn", { "reveal_target": "center" }]
       // also possible to spawn tasks by name:
       // "foo-bar": ["task::Spawn", { "task_name": "MyTask", "reveal_target": "dock" }]
+      // or by tag:
+      // "foo-bar": ["task::Spawn", { "task_tag": "MyTag" }],
     }
   },
   {
@@ -529,6 +534,7 @@
     "context": "Editor && showing_completions",
     "bindings": {
       "enter": "editor::ConfirmCompletion",
+      "shift-enter": "editor::ConfirmCompletionReplace",
       "tab": "editor::ComposeCompletion"
     }
   },
@@ -621,22 +627,29 @@
     "context": "AgentPanel",
     "bindings": {
       "ctrl-n": "agent::NewThread",
-      "new": "agent::NewThread",
-      "ctrl-alt-n": "agent::NewPromptEditor",
+      "ctrl-alt-n": "agent::NewTextThread",
       "ctrl-shift-h": "agent::OpenHistory",
       "ctrl-alt-c": "agent::OpenConfiguration",
       "ctrl-i": "agent::ToggleProfileSelector",
       "ctrl-alt-/": "assistant::ToggleModelSelector",
       "ctrl-shift-a": "agent::ToggleContextPicker",
+      "shift-escape": "agent::ExpandMessageEditor",
       "ctrl-e": "agent::ChatMode",
       "ctrl-alt-e": "agent::RemoveAllContext"
     }
   },
+  {
+    "context": "AgentPanel > Markdown",
+    "bindings": {
+      "copy": "markdown::CopyAsMarkdown",
+      "ctrl-c": "markdown::CopyAsMarkdown"
+    }
+  },
   {
     "context": "AgentPanel && prompt_editor",
     "use_key_equivalents": true,
     "bindings": {
-      "cmd-n": "agent::NewPromptEditor",
+      "cmd-n": "agent::NewTextThread",
       "cmd-alt-t": "agent::NewThread"
     }
   },
@@ -657,6 +670,15 @@
       "alt-enter": "editor::Newline"
     }
   },
+  {
+    "context": "AgentFeedbackMessageEditor > Editor",
+    "use_key_equivalents": true,
+    "bindings": {
+      "escape": "menu::Cancel",
+      "enter": "menu::Confirm",
+      "alt-enter": "editor::Newline"
+    }
+  },
   {
     "context": "ContextStrip",
     "bindings": {

assets/keymaps/default-macos.json

@@ -242,7 +242,9 @@
     "use_key_equivalents": true,
     "bindings": {
       "cmd-y": "agent::Keep",
-      "cmd-alt-z": "agent::Reject"
+      "cmd-n": "agent::Reject",
+      "cmd-shift-y": "agent::KeepAll",
+      "cmd-shift-n": "agent::RejectAll"
     }
   },
   {
@@ -281,21 +283,29 @@
     "use_key_equivalents": true,
     "bindings": {
       "cmd-n": "agent::NewThread",
-      "cmd-alt-n": "agent::NewPromptEditor",
+      "cmd-alt-n": "agent::NewTextThread",
       "cmd-shift-h": "agent::OpenHistory",
       "cmd-alt-c": "agent::OpenConfiguration",
       "cmd-i": "agent::ToggleProfileSelector",
       "cmd-alt-/": "assistant::ToggleModelSelector",
       "cmd-shift-a": "agent::ToggleContextPicker",
+      "shift-escape": "agent::ExpandMessageEditor",
       "cmd-e": "agent::ChatMode",
       "cmd-alt-e": "agent::RemoveAllContext"
     }
   },
+  {
+    "context": "AgentPanel > Markdown",
+    "use_key_equivalents": true,
+    "bindings": {
+      "cmd-c": "markdown::CopyAsMarkdown"
+    }
+  },
   {
     "context": "AgentPanel && prompt_editor",
     "use_key_equivalents": true,
     "bindings": {
-      "cmd-n": "agent::NewPromptEditor",
+      "cmd-n": "agent::NewTextThread",
       "cmd-alt-t": "agent::NewThread"
     }
   },
@@ -317,6 +327,15 @@
       "alt-enter": "editor::Newline"
     }
   },
+  {
+    "context": "AgentFeedbackMessageEditor > Editor",
+    "use_key_equivalents": true,
+    "bindings": {
+      "escape": "menu::Cancel",
+      "enter": "menu::Confirm",
+      "alt-enter": "editor::Newline"
+    }
+  },
   {
     "context": "ContextStrip",
     "use_key_equivalents": true,
@@ -329,10 +348,28 @@
       "enter": "agent::AcceptSuggestedContext"
     }
   },
+  {
+    "context": "AgentConfiguration",
+    "bindings": {
+      "ctrl--": "pane::GoBack"
+    }
+  },
   {
     "context": "ThreadHistory",
     "bindings": {
-      "backspace": "agent::RemoveSelectedThread"
+      "ctrl--": "pane::GoBack"
+    }
+  },
+  {
+    "context": "ThreadHistory",
+    "bindings": {
+      "ctrl--": "pane::GoBack"
+    }
+  },
+  {
+    "context": "ThreadHistory > Editor",
+    "bindings": {
+      "shift-backspace": "agent::RemoveSelectedThread"
     }
   },
   {
@@ -421,7 +458,8 @@
       "cmd-k e": ["pane::CloseItemsToTheLeft", { "close_pinned": false }],
       "cmd-k t": ["pane::CloseItemsToTheRight", { "close_pinned": false }],
       "cmd-k u": ["pane::CloseCleanItems", { "close_pinned": false }],
-      "cmd-k cmd-w": ["pane::CloseAllItems", { "close_pinned": false }],
+      "cmd-k w": ["pane::CloseAllItems", { "close_pinned": false }],
+      "cmd-k cmd-w": "workspace::CloseAllItemsAndPanes",
       "cmd-f": "project_search::ToggleFocus",
       "cmd-g": "search::SelectNextMatch",
       "cmd-shift-g": "search::SelectPreviousMatch",
@@ -490,7 +528,7 @@
       "cmd-k cmd-9": ["editor::FoldAtLevel", 9],
       "cmd-k cmd-0": "editor::FoldAll",
       "cmd-k cmd-j": "editor::UnfoldAll",
-      // Using `ctrl-space` in Zed requires disabling the macOS global shortcut.
+      // Using `ctrl-space` / `ctrl-shift-space` in Zed requires disabling the macOS global shortcut.
       // System Preferences->Keyboard->Keyboard Shortcuts->Input Sources->Select the previous input source (uncheck)
       "ctrl-space": "editor::ShowCompletions",
       "ctrl-shift-space": "editor::ShowWordCompletions",
@@ -598,6 +636,8 @@
       "ctrl-alt-shift-r": ["task::Spawn", { "reveal_target": "center" }]
       // also possible to spawn tasks by name:
       // "foo-bar": ["task::Spawn", { "task_name": "MyTask", "reveal_target": "dock" }]
+      // or by tag:
+      // "foo-bar": ["task::Spawn", { "task_tag": "MyTag" }],
     }
   },
   // Bindings from Sublime Text
@@ -644,6 +684,7 @@
     "use_key_equivalents": true,
     "bindings": {
       "enter": "editor::ConfirmCompletion",
+      "shift-enter": "editor::ConfirmCompletionReplace",
       "tab": "editor::ComposeCompletion"
     }
   },
@@ -966,6 +1007,8 @@
       "cmd-home": "terminal::ScrollToTop",
       "shift-end": "terminal::ScrollToBottom",
       "cmd-end": "terminal::ScrollToBottom",
+      // Using `ctrl-shift-space` in Zed requires disabling the macOS global shortcut.
+      // System Preferences->Keyboard->Keyboard Shortcuts->Input Sources->Select the previous input source (uncheck)
       "ctrl-shift-space": "terminal::ToggleViMode",
       "ctrl-k up": "pane::SplitUp",
       "ctrl-k down": "pane::SplitDown",

assets/keymaps/linux/jetbrains.json

@@ -58,7 +58,8 @@
       "ctrl-shift-home": "editor::SelectToBeginning",
       "ctrl-shift-end": "editor::SelectToEnd",
       "ctrl-f8": "editor::ToggleBreakpoint",
-      "ctrl-shift-f8": "editor::EditLogBreakpoint"
+      "ctrl-shift-f8": "editor::EditLogBreakpoint",
+      "ctrl-shift-u": "editor::ToggleCase"
     }
   },
   {

assets/keymaps/macos/jetbrains.json

@@ -55,7 +55,8 @@
       "cmd-shift-home": "editor::SelectToBeginning",
       "cmd-shift-end": "editor::SelectToEnd",
       "ctrl-f8": "editor::ToggleBreakpoint",
-      "ctrl-shift-f8": "editor::EditLogBreakpoint"
+      "ctrl-shift-f8": "editor::EditLogBreakpoint",
+      "cmd-shift-u": "editor::ToggleCase"
     }
   },
   {

assets/keymaps/vim.json

@@ -44,6 +44,12 @@
       "[ /": "vim::PreviousComment",
       "] *": "vim::NextComment",
       "] /": "vim::NextComment",
+      "[ -": "vim::PreviousLesserIndent",
+      "[ +": "vim::PreviousGreaterIndent",
+      "[ =": "vim::PreviousSameIndent",
+      "] -": "vim::NextLesserIndent",
+      "] +": "vim::NextGreaterIndent",
+      "] =": "vim::NextSameIndent",
       // Word motions
       "w": "vim::NextWordStart",
       "e": "vim::NextWordEnd",
@@ -335,27 +341,106 @@
     }
   },
   {
-    "context": "vim_mode == helix_normal",
+    "context": "vim_mode == helix_normal && !menu",
     "bindings": {
+      "escape": "editor::Cancel",
+      "ctrl-[": "editor::Cancel",
+      ":": "command_palette::Toggle",
+      "shift-d": "vim::DeleteToEndOfLine",
+      "shift-j": "vim::JoinLines",
+      "y": "editor::Copy",
+      "shift-y": "vim::YankLine",
       "i": "vim::InsertBefore",
+      "shift-i": "vim::InsertFirstNonWhitespace",
       "a": "vim::InsertAfter",
-      "d": "vim::HelixDelete",
-      "w": "vim::NextWordStart",
-      "e": "vim::NextWordEnd",
-      "b": "vim::PreviousWordStart",
+      "shift-a": "vim::InsertEndOfLine",
+      "o": "vim::InsertLineBelow",
+      "shift-o": "vim::InsertLineAbove",
+      "~": "vim::ChangeCase",
+      "ctrl-a": "vim::Increment",
+      "ctrl-x": "vim::Decrement",
+      "p": "vim::Paste",
+      "shift-p": ["vim::Paste", { "before": true }],
+      "u": "vim::Undo",
+      "ctrl-r": "vim::Redo",
+      "r": "vim::PushReplace",
+      "s": "vim::Substitute",
+      "shift-s": "vim::SubstituteLine",
+      ">": "vim::Indent",
+      "<": "vim::Outdent",
+      "=": "vim::AutoIndent",
+      "g u": "vim::PushLowercase",
+      "g shift-u": "vim::PushUppercase",
+      "g ~": "vim::PushOppositeCase",
+      "\"": "vim::PushRegister",
+      "g q": "vim::PushRewrap",
+      "g w": "vim::PushRewrap",
+      "ctrl-pagedown": "pane::ActivateNextItem",
+      "ctrl-pageup": "pane::ActivatePreviousItem",
+      "insert": "vim::InsertBefore",
+      // tree-sitter related commands
+      "[ x": "editor::SelectLargerSyntaxNode",
+      "] x": "editor::SelectSmallerSyntaxNode",
+      "] d": "editor::GoToDiagnostic",
+      "[ d": "editor::GoToPreviousDiagnostic",
+      "] c": "editor::GoToHunk",
+      "[ c": "editor::GoToPreviousHunk",
+      // Goto mode
+      "g n": "pane::ActivateNextItem",
+      "g p": "pane::ActivatePreviousItem",
+      // "tab": "pane::ActivateNextItem",
+      // "shift-tab": "pane::ActivatePrevItem",
+      "shift-h": "pane::ActivatePreviousItem",
+      "shift-l": "pane::ActivateNextItem",
+      "g l": "vim::EndOfLine",
+      "g h": "vim::StartOfLine",
+      "g s": "vim::FirstNonWhitespace", // "g s" default behavior is "space s"
+      "g e": "vim::EndOfDocument",
+      "g y": "editor::GoToTypeDefinition",
+      "g r": "editor::FindAllReferences", // zed specific
+      "g t": "vim::WindowTop",
+      "g c": "vim::WindowMiddle",
+      "g b": "vim::WindowBottom",
 
-      "h": "vim::Left",
-      "j": "vim::Down",
-      "k": "vim::Up",
-      "l": "vim::Right"
+      "x": "editor::SelectLine",
+      "shift-x": "editor::SelectLine",
+      // Window mode
+      "space w h": "workspace::ActivatePaneLeft",
+      "space w l": "workspace::ActivatePaneRight",
+      "space w k": "workspace::ActivatePaneUp",
+      "space w j": "workspace::ActivatePaneDown",
+      "space w q": "pane::CloseActiveItem",
+      "space w s": "pane::SplitRight",
+      "space w r": "pane::SplitRight",
+      "space w v": "pane::SplitDown",
+      "space w d": "pane::SplitDown",
+      // Space mode
+      "space f": "file_finder::Toggle",
+      "space k": "editor::Hover",
+      "space s": "outline::Toggle",
+      "space shift-s": "project_symbols::Toggle",
+      "space d": "editor::GoToDiagnostic",
+      "space r": "editor::Rename",
+      "space a": "editor::ToggleCodeActions",
+      "space h": "editor::SelectAllMatches",
+      "space c": "editor::ToggleComments",
+      "space y": "editor::Copy",
+      "space p": "editor::Paste",
+      // Match mode
+      "m m": "vim::Matching",
+      "m i w": ["workspace::SendKeystrokes", "v i w"],
+      "shift-u": "editor::Redo",
+      "ctrl-c": "editor::ToggleComments",
+      "d": "vim::HelixDelete",
+      "c": "vim::Substitute",
+      "shift-c": "editor::AddSelectionBelow"
     }
   },
-
   {
     "context": "vim_mode == insert && !(showing_code_actions || showing_completions)",
     "bindings": {
-      "ctrl-p": "editor::ShowCompletions",
-      "ctrl-n": "editor::ShowCompletions"
+      "ctrl-p": "editor::ShowWordCompletions",
+      "ctrl-n": "editor::ShowWordCompletions"
     }
   },
   {

assets/prompts/assistant_system_prompt.hbs

@@ -6,15 +6,26 @@ You are an AI assistant integrated into a code editor. You have the programming
 It will be up to you to decide which of these you are doing based on what the user has told you. When unclear, ask clarifying questions to understand the user's intent before proceeding.
 
 You should only perform actions that modify the user's system if explicitly requested by the user:
-- If the user asks a question about how to accomplish a task, provide guidance or information, and use read-only tools (e.g., search) to assist. You may suggest potential actions, but do not directly modify the user’s system without explicit instruction.
+- If the user asks a question about how to accomplish a task, provide guidance or information, and use read-only tools (e.g., search) to assist. You may suggest potential actions, but do not directly modify the user's system without explicit instruction.
 - If the user clearly requests that you perform an action, carry out the action directly without explaining why you are doing so.
 
+When answering questions, it's okay to give incomplete examples containing comments about what would go there in a real version. When being asked to directly perform tasks on the code base, you must ALWAYS make fully working code. You may never "simplify" the code by omitting or deleting functionality you know the user has requested, and you must NEVER write comments like "in a full version, this would..." - instead, you must actually implement the real version. Don't be lazy!
+
+Note that project files are automatically backed up. The user can always get them back later if anything goes wrong, so there's
+no need to create backup files (e.g. `.bak` files) because these files will just take up unnecessary space on the user's disk.
+
+When attempting to resolve issues around failing tests, never simply remove the failing tests. Unless the user explicitly asks you to remove tests, ALWAYS attempt to fix the code causing the tests to fail.
+
+Ignore "TODO"-type comments unless they're relevant to the user's explicit request or the user specifically asks you to address them. It is, however, okay to include them in codebase summaries.
+
+<style>
 Editing code:
 - Make sure to take previous edits into account.
 - The edits you perform might lead to errors or warnings. At the end of your changes, check whether you introduced any problems, and fix them before providing a summary of the changes you made.
 - You may only attempt to fix these up to 3 times. If you have tried 3 times to fix them, and there are still problems remaining, you must not continue trying to fix them, and must instead tell the user that there are problems remaining - and ask if the user would like you to attempt to solve them further.
 - Do not fix errors unrelated to your changes unless the user explicitly asks you to do so.
 - Prefer to move files over recreating them. The move can be followed by minor edits if required.
+- If you seem to be stuck, never go back and "simplify the implementation" by deleting the parts of the implementation you're stuck on and replacing them with comments. If you ever feel the urge to do this, instead immediately stop whatever you're doing (even if the code is in a broken state), report that you are stuck, explain what you're stuck on, and ask the user how to proceed.
 
 Tool use:
 - Make sure to adhere to the tools schema.
@@ -33,6 +44,106 @@ Responding:
     For example, don't say "Now I'm going to check diagnostics to see if there are any warnings or errors," followed by running a tool which checks diagnostics and reports warnings or errors; instead, just request the tool call without saying anything.
 - All tool results are provided to you automatically, so DO NOT thank the user when this happens.
 
+Whenever you mention a code block, you MUST use ONLY the following format:
+
+```language path/to/Something.blah#L123-456
+(code goes here)
+```
+
+The `#L123-456` means the line number range 123 through 456, and the path/to/Something.blah
+is a path in the project. (If there is no valid path in the project, then you can use
+/dev/null/path.extension for its path.) This is the ONLY valid way to format code blocks, because the Markdown parser
+does not understand the more common ```language syntax, or bare ``` blocks. It only
+understands this path-based syntax, and if the path is missing, then it will error and you will have to do it over again.
+
+Just to be really clear about this, if you ever find yourself writing three backticks followed by a language name, STOP!
+You have made a mistake. You can only ever put paths after triple backticks!
+
+<example>
+Based on all the information I've gathered, here's a summary of how this system works:
+1. The README file is loaded into the system.
+2. The system finds the first two headers, including everything in between. In this case, that would be:
+
+```path/to/README.md#L8-12
+# First Header
+
+This is the info under the first header.
+
+## Sub-header
+```
+
+3. Then the system finds the last header in the README:
+
+```path/to/README.md#L27-29
+## Last Header
+
+This is the last header in the README.
+```
+
+4. Finally, it passes this information on to the next process.
+</example>
+
+<example>
+In Markdown, hash marks signify headings. For example:
+
+```/dev/null/example.md#L1-3
+# Level 1 heading
+## Level 2 heading
+### Level 3 heading
+```
+</example>
+
+Here are examples of ways you must never render code blocks:
+
+<bad_example_do_not_do_this>
+In Markdown, hash marks signify headings. For example:
+
+```
+# Level 1 heading
+## Level 2 heading
+### Level 3 heading
+```
+</bad_example_do_not_do_this>
+
+This example is unacceptable because it does not include the path.
+
+<bad_example_do_not_do_this>
+In Markdown, hash marks signify headings. For example:
+
+```markdown
+# Level 1 heading
+## Level 2 heading
+### Level 3 heading
+```
+</bad_example_do_not_do_this>
+
+This example is unacceptable because it has the language instead of the path.
+
+<bad_example_do_not_do_this>
+In Markdown, hash marks signify headings. For example:
+
+    # Level 1 heading
+    ## Level 2 heading
+    ### Level 3 heading
+</bad_example_do_not_do_this>
+
+This example is unacceptable because it uses indentation to mark the code block
+instead of backticks with a path.
+
+<bad_example_do_not_do_this>
+In Markdown, hash marks signify headings. For example:
+
+```markdown
+/dev/null/example.md#L1-3
+# Level 1 heading
+## Level 2 heading
+### Level 3 heading
+```
+</bad_example_do_not_do_this>
+
+This example is unacceptable because the path is in the wrong place. The path must be directly after the opening backticks.
+</style>
+
 The user has opened a project that contains the following root directories/files. Whenever you specify a path in the project, it must be a relative path which begins with one of these root directories/files:
 
 {{#each worktrees}}
@@ -44,7 +155,7 @@ There are rules that apply to these root directories:
 {{#each worktrees}}
 {{#if rules_file}}
 
-`{{root_name}}/{{rules_file.rel_path}}`:
+`{{root_name}}/{{rules_file.path_in_worktree}}`:
 
 ``````
 {{{rules_file.text}}}
@@ -52,3 +163,8 @@ There are rules that apply to these root directories:
 {{/if}}
 {{/each}}
 {{/if}}
+
+<user_environment>
+Operating System: {{os}} ({{arch}})
+Shell: {{shell}}
+</user_environment>

assets/prompts/project_slash_command.hbs

@@ -1,8 +0,0 @@
-A software developer is asking a question about their project. The source files in their project have been indexed into a database of semantic text embeddings.
-Your task is to generate a list of 4 diverse search queries that can be run on this embedding database, in order to retrieve a list of code snippets
-that are relevant to the developer's question. Redundant search queries will be heavily penalized, so only include another query if it's sufficiently
-distinct from previous ones.
-
-Here is the question that's been asked, together with context that the developer has added manually:
-
-{{{context_buffer}}}

assets/settings/default.json

@@ -624,14 +624,14 @@
       // The provider to use.
       "provider": "zed.dev",
       // The model to use.
-      "model": "claude-3-5-sonnet-latest"
+      "model": "claude-3-7-sonnet-latest"
     },
     // The model to use when applying edits from the assistant.
     "editor_model": {
       // The provider to use.
       "provider": "zed.dev",
       // The model to use.
-      "model": "claude-3-5-sonnet-latest"
+      "model": "claude-3-7-sonnet-latest"
     },
     // When enabled, the agent can run potentially destructive actions without asking for your confirmation.
     "always_allow_tool_actions": false,
@@ -644,7 +644,7 @@
         "tools": {
           "diagnostics": true,
           "fetch": true,
-          "list_directory": true,
+          "list_directory": false,
           "now": true,
           "path_search": true,
           "read_file": true,
@@ -656,22 +656,23 @@
         "name": "Write",
         "enable_all_context_servers": true,
         "tools": {
-          "bash": true,
+          "terminal": true,
           "batch_tool": true,
+          "code_actions": true,
           "code_symbols": true,
-          "copy_path": true,
+          "copy_path": false,
           "create_file": true,
-          "delete_path": true,
+          "delete_path": false,
           "diagnostics": true,
           "find_replace_file": true,
-          "edit_files": false,
           "fetch": true,
-          "list_directory": true,
-          "move_path": true,
+          "list_directory": false,
+          "move_path": false,
           "now": true,
           "path_search": true,
           "read_file": true,
           "regex_search": true,
+          "rename": true,
           "symbol_info": true,
           "thinking": true
         }
@@ -1137,7 +1138,8 @@
   "code_actions_on_format": {},
   // Settings related to running tasks.
   "tasks": {
-    "variables": {}
+    "variables": {},
+    "enabled": true
   },
   // An object whose keys are language names, and whose values
   // are arrays of filenames or extensions of files that should
@@ -1201,7 +1203,27 @@
     // When set to 0, waits indefinitely.
     //
     // Default: 0
-    "lsp_fetch_timeout_ms": 0
+    "lsp_fetch_timeout_ms": 0,
+    // Controls what range to replace when accepting LSP completions.
+    //
+    // When LSP servers give an `InsertReplaceEdit` completion, they provides two ranges: `insert` and `replace`. Usually, `insert`
+    // contains the word prefix before your cursor and `replace` contains the whole word.
+    //
+    // Effectively, this setting just changes whether Zed will use the received range for `insert` or `replace`, so the results may
+    // differ depending on the underlying LSP server.
+    //
+    // Possible values:
+    // 1. "insert"
+    //   Replaces text before the cursor, using the `insert` range described in the LSP specification.
+    // 2. "replace"
+    //   Replaces text before and after the cursor, using the `replace` range described in the LSP specification.
+    // 3. "replace_subsequence"
+    //   Behaves like `"replace"` if the text that would be replaced is a subsequence of the completion text,
+    //   and like `"insert"` otherwise.
+    // 4. "replace_suffix"
+    //   Behaves like `"replace"` if the text after the cursor is a suffix of the completion, and like
+    //   `"insert"` otherwise.
+    "lsp_insert_mode": "replace_suffix"
   },
   // Different settings for specific languages.
   "languages": {
@@ -1437,6 +1459,8 @@
   "lsp": {
     // Specify the LSP name as a key here.
     // "rust-analyzer": {
+    //     // A special flag for rust-analyzer integration, to use server-provided tasks
+    //     enable_lsp_tasks": true,
     //     // These initialization options are merged into Zed's defaults
     //     "initialization_options": {
     //         "check": {

assets/settings/initial_tasks.json

@@ -43,6 +43,8 @@
     //           "args": ["--login"]
     //         }
     //     }
-    "shell": "system"
+    "shell": "system",
+    // Represents the tags for inline runnable indicators, or spawning multiple tasks at once.
+    "tags": []
   }
 ]

assets/themes/gruvbox/gruvbox.json

@@ -87,9 +87,9 @@
         "terminal.ansi.blue": "#83a598ff",
         "terminal.ansi.bright_blue": "#414f4aff",
         "terminal.ansi.dim_blue": "#c0d2cbff",
-        "terminal.ansi.magenta": "#a89984ff",
-        "terminal.ansi.bright_magenta": "#514a41ff",
-        "terminal.ansi.dim_magenta": "#d2cabfff",
+        "terminal.ansi.magenta": "#d3869bff",
+        "terminal.ansi.bright_magenta": "#8e5868ff",
+        "terminal.ansi.dim_magenta": "#ff9ebbff",
         "terminal.ansi.cyan": "#8ec07cff",
         "terminal.ansi.bright_cyan": "#45603eff",
         "terminal.ansi.dim_cyan": "#c7dfbdff",
@@ -472,9 +472,9 @@
         "terminal.ansi.blue": "#83a598ff",
         "terminal.ansi.bright_blue": "#414f4aff",
         "terminal.ansi.dim_blue": "#c0d2cbff",
-        "terminal.ansi.magenta": "#a89984ff",
-        "terminal.ansi.bright_magenta": "#514a41ff",
-        "terminal.ansi.dim_magenta": "#d2cabfff",
+        "terminal.ansi.magenta": "#d3869bff",
+        "terminal.ansi.bright_magenta": "#8e5868ff",
+        "terminal.ansi.dim_magenta": "#ff9ebbff",
         "terminal.ansi.cyan": "#8ec07cff",
         "terminal.ansi.bright_cyan": "#45603eff",
         "terminal.ansi.dim_cyan": "#c7dfbdff",
@@ -857,9 +857,9 @@
         "terminal.ansi.blue": "#83a598ff",
         "terminal.ansi.bright_blue": "#414f4aff",
         "terminal.ansi.dim_blue": "#c0d2cbff",
-        "terminal.ansi.magenta": "#a89984ff",
-        "terminal.ansi.bright_magenta": "#514a41ff",
-        "terminal.ansi.dim_magenta": "#d2cabfff",
+        "terminal.ansi.magenta": "#d3869bff",
+        "terminal.ansi.bright_magenta": "#8e5868ff",
+        "terminal.ansi.dim_magenta": "#ff9ebbff",
         "terminal.ansi.cyan": "#8ec07cff",
         "terminal.ansi.bright_cyan": "#45603eff",
         "terminal.ansi.dim_cyan": "#c7dfbdff",
@@ -1242,9 +1242,9 @@
         "terminal.ansi.blue": "#0b6678ff",
         "terminal.ansi.bright_blue": "#8fb0baff",
         "terminal.ansi.dim_blue": "#14333bff",
-        "terminal.ansi.magenta": "#7c6f64ff",
-        "terminal.ansi.bright_magenta": "#bcb5afff",
-        "terminal.ansi.dim_magenta": "#3e3833ff",
+        "terminal.ansi.magenta": "#8f3e71ff",
+        "terminal.ansi.bright_magenta": "#c76da0ff",
+        "terminal.ansi.dim_magenta": "#5c2848ff",
         "terminal.ansi.cyan": "#437b59ff",
         "terminal.ansi.bright_cyan": "#9fbca8ff",
         "terminal.ansi.dim_cyan": "#253e2eff",
@@ -1627,9 +1627,9 @@
         "terminal.ansi.blue": "#0b6678ff",
         "terminal.ansi.bright_blue": "#8fb0baff",
         "terminal.ansi.dim_blue": "#14333bff",
-        "terminal.ansi.magenta": "#7c6f64ff",
-        "terminal.ansi.bright_magenta": "#bcb5afff",
-        "terminal.ansi.dim_magenta": "#3e3833ff",
+        "terminal.ansi.magenta": "#8f3e71ff",
+        "terminal.ansi.bright_magenta": "#c76da0ff",
+        "terminal.ansi.dim_magenta": "#5c2848ff",
         "terminal.ansi.cyan": "#437b59ff",
         "terminal.ansi.bright_cyan": "#9fbca8ff",
         "terminal.ansi.dim_cyan": "#253e2eff",
@@ -2012,9 +2012,9 @@
         "terminal.ansi.blue": "#0b6678ff",
         "terminal.ansi.bright_blue": "#8fb0baff",
         "terminal.ansi.dim_blue": "#14333bff",
-        "terminal.ansi.magenta": "#7c6f64ff",
-        "terminal.ansi.bright_magenta": "#bcb5afff",
-        "terminal.ansi.dim_magenta": "#3e3833ff",
+        "terminal.ansi.magenta": "#8f3e71ff",
+        "terminal.ansi.bright_magenta": "#c76da0ff",
+        "terminal.ansi.dim_magenta": "#5c2848ff",
         "terminal.ansi.cyan": "#437b59ff",
         "terminal.ansi.bright_cyan": "#9fbca8ff",
         "terminal.ansi.dim_cyan": "#253e2eff",

crates/activity_indicator/Cargo.toml

@@ -25,6 +25,7 @@ smallvec.workspace = true
 ui.workspace = true
 util.workspace = true
 workspace.workspace = true
+workspace-hack.workspace = true
 
 [dev-dependencies]
 editor = { workspace = true, features = ["test-support"] }

crates/activity_indicator/src/activity_indicator.rs

@@ -11,13 +11,22 @@ use language::{BinaryStatus, LanguageRegistry, LanguageServerId};
 use project::{
     EnvironmentErrorMessage, LanguageServerProgress, LspStoreEvent, Project,
     ProjectEnvironmentEvent,
+    git_store::{GitStoreEvent, Repository},
 };
 use smallvec::SmallVec;
-use std::{cmp::Reverse, fmt::Write, path::Path, sync::Arc, time::Duration};
+use std::{
+    cmp::Reverse,
+    fmt::Write,
+    path::Path,
+    sync::Arc,
+    time::{Duration, Instant},
+};
 use ui::{ButtonLike, ContextMenu, PopoverMenu, PopoverMenuHandle, Tooltip, prelude::*};
 use util::truncate_and_trailoff;
 use workspace::{StatusItemView, Workspace, item::ItemHandle};
 
+const GIT_OPERATION_DELAY: Duration = Duration::from_millis(0);
+
 actions!(activity_indicator, [ShowErrorMessage]);
 
 pub enum Event {
@@ -105,6 +114,15 @@ impl ActivityIndicator {
             )
             .detach();
 
+            cx.subscribe(
+                &project.read(cx).git_store().clone(),
+                |_, _, event: &GitStoreEvent, cx| match event {
+                    project::git_store::GitStoreEvent::JobsUpdated => cx.notify(),
+                    _ => {}
+                },
+            )
+            .detach();
+
             if let Some(auto_updater) = auto_updater.as_ref() {
                 cx.observe(auto_updater, |_, _, cx| cx.notify()).detach();
             }
@@ -285,6 +303,34 @@ impl ActivityIndicator {
             });
         }
 
+        let current_job = self
+            .project
+            .read(cx)
+            .active_repository(cx)
+            .map(|r| r.read(cx))
+            .and_then(Repository::current_job);
+        // Show any long-running git command
+        if let Some(job_info) = current_job {
+            if Instant::now() - job_info.start >= GIT_OPERATION_DELAY {
+                return Some(Content {
+                    icon: Some(
+                        Icon::new(IconName::ArrowCircle)
+                            .size(IconSize::Small)
+                            .with_animation(
+                                "arrow-circle",
+                                Animation::new(Duration::from_secs(2)).repeat(),
+                                |icon, delta| {
+                                    icon.transform(Transformation::rotate(percentage(delta)))
+                                },
+                            )
+                            .into_any_element(),
+                    ),
+                    message: job_info.message.into(),
+                    on_click: None,
+                });
+            }
+        }
+
         // Show any language server installation info.
         let mut downloading = SmallVec::<[_; 3]>::new();
         let mut checking_for_update = SmallVec::<[_; 3]>::new();

crates/agent/Cargo.toml

@@ -31,6 +31,7 @@ client.workspace = true
 clock.workspace = true
 collections.workspace = true
 command_palette_hooks.workspace = true
+component.workspace = true
 context_server.workspace = true
 convert_case.workspace = true
 db.workspace = true
@@ -50,6 +51,7 @@ itertools.workspace = true
 language.workspace = true
 language_model.workspace = true
 language_model_selector.workspace = true
+linkme.workspace = true
 log.workspace = true
 lsp.workspace = true
 markdown.workspace = true
@@ -78,12 +80,14 @@ terminal.workspace = true
 terminal_view.workspace = true
 text.workspace = true
 theme.workspace = true
+thiserror.workspace = true
 time.workspace = true
 time_format.workspace = true
 ui.workspace = true
+ui_input.workspace = true
 util.workspace = true
 uuid.workspace = true
-vim_mode_setting.workspace = true
+workspace-hack.workspace = true
 workspace.workspace = true
 zed_actions.workspace = true
 

crates/agent/src/agent_diff.rs

@@ -1,9 +1,9 @@
-use crate::{Thread, ThreadEvent};
+use crate::{Keep, KeepAll, Reject, RejectAll, Thread, ThreadEvent};
 use anyhow::Result;
 use buffer_diff::DiffHunkStatus;
 use collections::HashSet;
 use editor::{
-    AnchorRangeExt, Direction, Editor, EditorEvent, MultiBuffer, ToPoint,
+    Direction, Editor, EditorEvent, MultiBuffer, ToPoint,
     actions::{GoToHunk, GoToPreviousHunk},
     scroll::Autoscroll,
 };
@@ -26,6 +26,7 @@ use workspace::{
     item::{BreadcrumbText, ItemEvent, TabContentParams},
     searchable::SearchableItemHandle,
 };
+use zed_actions::assistant::ToggleFocus;
 
 pub struct AgentDiff {
     multibuffer: Entity<MultiBuffer>,
@@ -43,22 +44,29 @@ impl AgentDiff {
         workspace: WeakEntity<Workspace>,
         window: &mut Window,
         cx: &mut App,
-    ) -> Result<()> {
-        let existing_diff = workspace.update(cx, |workspace, cx| {
-            workspace
-                .items_of_type::<AgentDiff>(cx)
-                .find(|diff| diff.read(cx).thread == thread)
-        })?;
+    ) -> Result<Entity<Self>> {
+        workspace.update(cx, |workspace, cx| {
+            Self::deploy_in_workspace(thread, workspace, window, cx)
+        })
+    }
+
+    pub fn deploy_in_workspace(
+        thread: Entity<Thread>,
+        workspace: &mut Workspace,
+        window: &mut Window,
+        cx: &mut Context<Workspace>,
+    ) -> Entity<Self> {
+        let existing_diff = workspace
+            .items_of_type::<AgentDiff>(cx)
+            .find(|diff| diff.read(cx).thread == thread);
         if let Some(existing_diff) = existing_diff {
-            workspace.update(cx, |workspace, cx| {
-                workspace.activate_item(&existing_diff, true, true, window, cx);
-            })
+            workspace.activate_item(&existing_diff, true, true, window, cx);
+            existing_diff
         } else {
             let agent_diff =
-                cx.new(|cx| AgentDiff::new(thread.clone(), workspace.clone(), window, cx));
-            workspace.update(cx, |workspace, cx| {
-                workspace.add_item_to_center(Box::new(agent_diff), window, cx);
-            })
+                cx.new(|cx| AgentDiff::new(thread.clone(), workspace.weak_handle(), window, cx));
+            workspace.add_item_to_center(Box::new(agent_diff.clone()), window, cx);
+            agent_diff
         }
     }
 
@@ -133,11 +141,11 @@ impl AgentDiff {
         let mut paths_to_delete = self.multibuffer.read(cx).paths().collect::<HashSet<_>>();
 
         for (buffer, diff_handle) in changed_buffers {
-            let Some(file) = buffer.read(cx).file().cloned() else {
+            if buffer.read(cx).file().is_none() {
                 continue;
-            };
+            }
 
-            let path_key = PathKey::namespaced(0, file.full_path(cx).into());
+            let path_key = PathKey::for_buffer(&buffer, cx);
             paths_to_delete.remove(&path_key);
 
             let snapshot = buffer.read(cx).snapshot();
@@ -235,11 +243,31 @@ impl AgentDiff {
 
     fn handle_thread_event(&mut self, event: &ThreadEvent, cx: &mut Context<Self>) {
         match event {
-            ThreadEvent::SummaryChanged => self.update_title(cx),
+            ThreadEvent::SummaryGenerated => self.update_title(cx),
             _ => {}
         }
     }
 
+    pub fn move_to_path(&mut self, path_key: PathKey, window: &mut Window, cx: &mut Context<Self>) {
+        if let Some(position) = self.multibuffer.read(cx).location_for_path(&path_key, cx) {
+            self.editor.update(cx, |editor, cx| {
+                let first_hunk = editor
+                    .diff_hunks_in_ranges(
+                        &[position..editor::Anchor::max()],
+                        &self.multibuffer.read(cx).read(cx),
+                    )
+                    .next();
+
+                if let Some(first_hunk) = first_hunk {
+                    let first_hunk_start = first_hunk.multi_buffer_range().start;
+                    editor.change_selections(Some(Autoscroll::fit()), window, cx, |selections| {
+                        selections.select_anchor_ranges([first_hunk_start..first_hunk_start]);
+                    })
+                }
+            });
+        }
+    }
+
     fn keep(&mut self, _: &crate::Keep, window: &mut Window, cx: &mut Context<Self>) {
         let ranges = self
             .editor
@@ -327,13 +355,16 @@ impl AgentDiff {
             self.update_selection(&diff_hunks_in_ranges, window, cx);
         }
 
-        let point_ranges = ranges
-            .into_iter()
-            .map(|range| range.to_point(&snapshot))
-            .collect();
-        self.editor.update(cx, |editor, cx| {
-            editor.restore_hunks_in_ranges(point_ranges, window, cx)
-        });
+        for hunk in &diff_hunks_in_ranges {
+            let buffer = self.multibuffer.read(cx).buffer(hunk.buffer_id);
+            if let Some(buffer) = buffer {
+                self.thread
+                    .update(cx, |thread, cx| {
+                        thread.reject_edits_in_range(buffer, hunk.buffer_range.clone(), cx)
+                    })
+                    .detach_and_log_err(cx);
+            }
+        }
     }
 
     fn update_selection(
@@ -553,11 +584,12 @@ impl Item for AgentDiff {
 }
 
 impl Render for AgentDiff {
-    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
         let is_empty = self.multibuffer.read(cx).is_empty();
+        let focus_handle = &self.focus_handle;
 
         div()
-            .track_focus(&self.focus_handle)
+            .track_focus(focus_handle)
             .key_context(if is_empty { "EmptyPane" } else { "AgentDiff" })
             .on_action(cx.listener(Self::keep))
             .on_action(cx.listener(Self::reject))
@@ -568,7 +600,32 @@ impl Render for AgentDiff {
             .items_center()
             .justify_center()
             .size_full()
-            .when(is_empty, |el| el.child("No changes to review"))
+            .when(is_empty, |el| {
+                el.child(
+                    v_flex()
+                        .items_center()
+                        .gap_2()
+                        .child("No changes to review")
+                        .child(
+                            Button::new("continue-iterating", "Continue Iterating")
+                                .style(ButtonStyle::Filled)
+                                .icon(IconName::ForwardArrow)
+                                .icon_position(IconPosition::Start)
+                                .icon_size(IconSize::Small)
+                                .icon_color(Color::Muted)
+                                .full_width()
+                                .key_binding(KeyBinding::for_action_in(
+                                    &ToggleFocus,
+                                    &focus_handle.clone(),
+                                    window,
+                                    cx,
+                                ))
+                                .on_click(|_event, window, cx| {
+                                    window.dispatch_action(ToggleFocus.boxed_clone(), cx)
+                                }),
+                        ),
+                )
+            })
             .when(!is_empty, |el| el.child(self.editor.clone()))
     }
 }
@@ -604,7 +661,7 @@ fn render_diff_hunk_controls(
                 .disabled(is_created_file)
                 .key_binding(
                     KeyBinding::for_action_in(
-                        &crate::Reject,
+                        &Reject,
                         &editor.read(cx).focus_handle(cx),
                         window,
                         cx,
@@ -625,13 +682,8 @@ fn render_diff_hunk_controls(
                 }),
             Button::new(("keep", row as u64), "Keep")
                 .key_binding(
-                    KeyBinding::for_action_in(
-                        &crate::Keep,
-                        &editor.read(cx).focus_handle(cx),
-                        window,
-                        cx,
-                    )
-                    .map(|kb| kb.size(rems_from_px(12.))),
+                    KeyBinding::for_action_in(&Keep, &editor.read(cx).focus_handle(cx), window, cx)
+                        .map(|kb| kb.size(rems_from_px(12.))),
                 )
                 .on_click({
                     let agent_diff = agent_diff.clone();
@@ -740,15 +792,11 @@ impl editor::Addon for AgentDiffAddon {
 
 pub struct AgentDiffToolbar {
     agent_diff: Option<WeakEntity<AgentDiff>>,
-    _workspace: WeakEntity<Workspace>,
 }
 
 impl AgentDiffToolbar {
-    pub fn new(workspace: &Workspace, _: &mut Context<Self>) -> Self {
-        Self {
-            agent_diff: None,
-            _workspace: workspace.weak_handle(),
-        }
+    pub fn new() -> Self {
+        Self { agent_diff: None }
     }
 
     fn agent_diff(&self, _: &App) -> Option<Entity<AgentDiff>> {
@@ -795,7 +843,7 @@ impl ToolbarItemView for AgentDiffToolbar {
 }
 
 impl Render for AgentDiffToolbar {
-    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
         let agent_diff = match self.agent_diff(cx) {
             Some(ad) => ad,
             None => return div(),
@@ -807,6 +855,8 @@ impl Render for AgentDiffToolbar {
             return div();
         }
 
+        let focus_handle = agent_diff.focus_handle(cx);
+
         h_group_xl()
             .my_neg_1()
             .items_center()
@@ -816,15 +866,25 @@ impl Render for AgentDiffToolbar {
             .child(
                 h_group_sm()
                     .child(
-                        Button::new("reject-all", "Reject All").on_click(cx.listener(
-                            |this, _, window, cx| {
-                                this.dispatch_action(&crate::RejectAll, window, cx)
-                            },
-                        )),
+                        Button::new("reject-all", "Reject All")
+                            .key_binding({
+                                KeyBinding::for_action_in(&RejectAll, &focus_handle, window, cx)
+                                    .map(|kb| kb.size(rems_from_px(12.)))
+                            })
+                            .on_click(cx.listener(|this, _, window, cx| {
+                                this.dispatch_action(&RejectAll, window, cx)
+                            })),
                     )
-                    .child(Button::new("keep-all", "Keep All").on_click(cx.listener(
-                        |this, _, window, cx| this.dispatch_action(&crate::KeepAll, window, cx),
-                    ))),
+                    .child(
+                        Button::new("keep-all", "Keep All")
+                            .key_binding({
+                                KeyBinding::for_action_in(&KeepAll, &focus_handle, window, cx)
+                                    .map(|kb| kb.size(rems_from_px(12.)))
+                            })
+                            .on_click(cx.listener(|this, _, window, cx| {
+                                this.dispatch_action(&KeepAll, window, cx)
+                            })),
+                    ),
             )
     }
 }
@@ -873,15 +933,16 @@ mod tests {
             })
             .unwrap();
 
-        let thread_store = cx.update(|cx| {
-            ThreadStore::new(
-                project.clone(),
-                Arc::default(),
-                Arc::new(PromptBuilder::new(None).unwrap()),
-                cx,
-            )
-            .unwrap()
-        });
+        let thread_store = cx
+            .update(|cx| {
+                ThreadStore::load(
+                    project.clone(),
+                    Arc::default(),
+                    Arc::new(PromptBuilder::new(None).unwrap()),
+                    cx,
+                )
+            })
+            .await;
         let thread = thread_store.update(cx, |store, cx| store.create_thread(cx));
         let action_log = thread.read_with(cx, |thread, _| thread.action_log().clone());
 
@@ -942,7 +1003,7 @@ mod tests {
             Point::new(3, 0)..Point::new(3, 0)
         );
 
-        // Restoring a hunk also moves the cursor to the next hunk, possibly cycling if it's at the end.
+        // Rejecting a hunk also moves the cursor to the next hunk, possibly cycling if it's at the end.
         editor.update_in(cx, |editor, window, cx| {
             editor.change_selections(None, window, cx, |selections| {
                 selections.select_ranges([Point::new(10, 0)..Point::new(10, 0)])

crates/agent/src/assistant.rs

@@ -46,12 +46,12 @@ pub use agent_diff::{AgentDiff, AgentDiffToolbar};
 actions!(
     agent,
     [
-        NewPromptEditor,
+        NewTextThread,
         ToggleContextPicker,
         ToggleProfileSelector,
         RemoveAllContext,
+        ExpandMessageEditor,
         OpenHistory,
-        OpenConfiguration,
         AddContextServer,
         RemoveSelectedThread,
         Chat,

crates/agent/src/assistant_configuration.rs

@@ -12,7 +12,9 @@ use fs::Fs;
 use gpui::{Action, AnyView, App, Entity, EventEmitter, FocusHandle, Focusable, Subscription};
 use language_model::{LanguageModelProvider, LanguageModelProviderId, LanguageModelRegistry};
 use settings::{Settings, update_settings_file};
-use ui::{Disclosure, Divider, DividerColor, ElevationIndex, Indicator, Switch, prelude::*};
+use ui::{
+    Disclosure, Divider, DividerColor, ElevationIndex, Indicator, Switch, Tooltip, prelude::*,
+};
 use util::ResultExt as _;
 use zed_actions::ExtensionCategoryFilter;
 
@@ -236,7 +238,10 @@ impl AssistantConfiguration {
             .child(
                 v_flex()
                     .gap_0p5()
-                    .child(Headline::new("Context Servers (MCP)").size(HeadlineSize::Small))
+                    .child(
+                        Headline::new("Model Context Protocol (MCP) Servers")
+                            .size(HeadlineSize::Small),
+                    )
                     .child(Label::new(SUBHEADING).color(Color::Muted)),
             )
             .children(context_servers.into_iter().map(|context_server| {
@@ -262,10 +267,9 @@ impl AssistantConfiguration {
                     .bg(cx.theme().colors().editor_background)
                     .child(
                         h_flex()
+                            .p_1()
                             .justify_between()
-                            .px_2()
-                            .py_1()
-                            .when(are_tools_expanded, |element| {
+                            .when(are_tools_expanded && tool_count > 1, |element| {
                                 element
                                     .border_b_1()
                                     .border_color(cx.theme().colors().border)
@@ -275,6 +279,7 @@ impl AssistantConfiguration {
                                     .gap_2()
                                     .child(
                                         Disclosure::new("tool-list-disclosure", are_tools_expanded)
+                                            .disabled(tool_count == 0)
                                             .on_click(cx.listener({
                                                 let context_server_id = context_server.id();
                                                 move |this, _event, _window, _cx| {
@@ -295,10 +300,11 @@ impl AssistantConfiguration {
                                     .child(Label::new(context_server.id()))
                                     .child(
                                         Label::new(format!("{tool_count} tools"))
-                                            .color(Color::Muted),
+                                            .color(Color::Muted)
+                                            .size(LabelSize::Small),
                                     ),
                             )
-                            .child(h_flex().child(
+                            .child(
                                 Switch::new("context-server-switch", is_running.into()).on_click({
                                     let context_server_manager =
                                         self.context_server_manager.clone();
@@ -334,7 +340,7 @@ impl AssistantConfiguration {
                                         }
                                     }
                                 }),
-                            )),
+                            ),
                     )
                     .map(|parent| {
                         if !are_tools_expanded {
@@ -344,14 +350,29 @@ impl AssistantConfiguration {
                         parent.child(v_flex().children(tools.into_iter().enumerate().map(
                             |(ix, tool)| {
                                 h_flex()
-                                    .px_2()
+                                    .id("tool-item")
+                                    .pl_2()
+                                    .pr_1()
                                     .py_1()
+                                    .gap_2()
+                                    .justify_between()
                                     .when(ix < tool_count - 1, |element| {
                                         element
                                             .border_b_1()
-                                            .border_color(cx.theme().colors().border)
+                                            .border_color(cx.theme().colors().border_variant)
                                     })
-                                    .child(Label::new(tool.name()))
+                                    .child(
+                                        Label::new(tool.name())
+                                            .buffer_font(cx)
+                                            .size(LabelSize::Small),
+                                    )
+                                    .child(
+                                        IconButton::new(("tool-description", ix), IconName::Info)
+                                            .shape(ui::IconButtonShape::Square)
+                                            .icon_size(IconSize::Small)
+                                            .icon_color(Color::Ignored)
+                                            .tooltip(Tooltip::text(tool.description())),
+                                    )
                             },
                         )))
                     })
@@ -362,7 +383,7 @@ impl AssistantConfiguration {
                     .gap_2()
                     .child(
                         h_flex().w_full().child(
-                            Button::new("add-context-server", "Add Context Server")
+                            Button::new("add-context-server", "Add MCPs Directly")
                                 .style(ButtonStyle::Filled)
                                 .layer(ElevationIndex::ModalSurface)
                                 .full_width()
@@ -378,7 +399,7 @@ impl AssistantConfiguration {
                         h_flex().w_full().child(
                             Button::new(
                                 "install-context-server-extensions",
-                                "Install Context Server Extensions",
+                                "Install MCP Extensions",
                             )
                             .style(ButtonStyle::Filled)
                             .layer(ElevationIndex::ModalSurface)
@@ -409,6 +430,7 @@ impl Render for AssistantConfiguration {
 
         v_flex()
             .id("assistant-configuration")
+            .key_context("AgentConfiguration")
             .track_focus(&self.focus_handle(cx))
             .bg(cx.theme().colors().panel_background)
             .size_full()

crates/agent/src/assistant_configuration/add_context_server_modal.rs

@@ -1,17 +1,17 @@
 use context_server::{ContextServerSettings, ServerCommand, ServerConfig};
-use editor::Editor;
 use gpui::{DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, WeakEntity, prelude::*};
 use serde_json::json;
 use settings::update_settings_file;
 use ui::{Modal, ModalFooter, ModalHeader, Section, Tooltip, prelude::*};
+use ui_input::SingleLineInput;
 use workspace::{ModalView, Workspace};
 
 use crate::AddContextServer;
 
 pub struct AddContextServerModal {
     workspace: WeakEntity<Workspace>,
-    name_editor: Entity<Editor>,
-    command_editor: Entity<Editor>,
+    name_editor: Entity<SingleLineInput>,
+    command_editor: Entity<SingleLineInput>,
 }
 
 impl AddContextServerModal {
@@ -33,15 +33,10 @@ impl AddContextServerModal {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) -> Self {
-        let name_editor = cx.new(|cx| Editor::single_line(window, cx));
-        let command_editor = cx.new(|cx| Editor::single_line(window, cx));
-
-        name_editor.update(cx, |editor, cx| {
-            editor.set_placeholder_text("Context server name", cx);
-        });
-
-        command_editor.update(cx, |editor, cx| {
-            editor.set_placeholder_text("Command to run the context server", cx);
+        let name_editor =
+            cx.new(|cx| SingleLineInput::new(window, cx, "Your server name").label("Name"));
+        let command_editor = cx.new(|cx| {
+            SingleLineInput::new(window, cx, "Command").label("Command to run the context server")
         });
 
         Self {
@@ -52,8 +47,22 @@ impl AddContextServerModal {
     }
 
     fn confirm(&mut self, cx: &mut Context<Self>) {
-        let name = self.name_editor.read(cx).text(cx).trim().to_string();
-        let command = self.command_editor.read(cx).text(cx).trim().to_string();
+        let name = self
+            .name_editor
+            .read(cx)
+            .editor()
+            .read(cx)
+            .text(cx)
+            .trim()
+            .to_string();
+        let command = self
+            .command_editor
+            .read(cx)
+            .editor()
+            .read(cx)
+            .text(cx)
+            .trim()
+            .to_string();
 
         if name.is_empty() || command.is_empty() {
             return;
@@ -104,8 +113,8 @@ impl EventEmitter<DismissEvent> for AddContextServerModal {}
 
 impl Render for AddContextServerModal {
     fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let is_name_empty = self.name_editor.read(cx).text(cx).trim().is_empty();
-        let is_command_empty = self.command_editor.read(cx).text(cx).trim().is_empty();
+        let is_name_empty = self.name_editor.read(cx).is_empty(cx);
+        let is_command_empty = self.command_editor.read(cx).is_empty(cx);
 
         div()
             .elevation_3(cx)
@@ -122,18 +131,8 @@ impl Render for AddContextServerModal {
                     .header(ModalHeader::new().headline("Add Context Server"))
                     .section(
                         Section::new()
-                            .child(
-                                v_flex()
-                                    .gap_1()
-                                    .child(Label::new("Name"))
-                                    .child(self.name_editor.clone()),
-                            )
-                            .child(
-                                v_flex()
-                                    .gap_1()
-                                    .child(Label::new("Command"))
-                                    .child(self.command_editor.clone()),
-                            ),
+                            .child(self.name_editor.clone())
+                            .child(self.command_editor.clone()),
                     )
                     .footer(
                         ModalFooter::new()

crates/agent/src/assistant_configuration/tool_picker.rs

@@ -202,43 +202,43 @@ impl PickerDelegate for ToolPickerDelegate {
             let default_profile = self.profile.clone();
             let tool = tool.clone();
             move |settings, _cx| match settings {
-                AssistantSettingsContent::Versioned(VersionedAssistantSettingsContent::V2(
-                    settings,
-                )) => {
-                    let profiles = settings.profiles.get_or_insert_default();
-                    let profile =
-                        profiles
-                            .entry(profile_id)
-                            .or_insert_with(|| AgentProfileContent {
-                                name: default_profile.name.into(),
-                                tools: default_profile.tools,
-                                enable_all_context_servers: Some(
-                                    default_profile.enable_all_context_servers,
-                                ),
-                                context_servers: default_profile
-                                    .context_servers
-                                    .into_iter()
-                                    .map(|(server_id, preset)| {
-                                        (
-                                            server_id,
-                                            ContextServerPresetContent {
-                                                tools: preset.tools,
-                                            },
-                                        )
-                                    })
-                                    .collect(),
-                            });
+                AssistantSettingsContent::Versioned(boxed) => {
+                    if let VersionedAssistantSettingsContent::V2(ref mut settings) = **boxed {
+                        let profiles = settings.profiles.get_or_insert_default();
+                        let profile =
+                            profiles
+                                .entry(profile_id)
+                                .or_insert_with(|| AgentProfileContent {
+                                    name: default_profile.name.into(),
+                                    tools: default_profile.tools,
+                                    enable_all_context_servers: Some(
+                                        default_profile.enable_all_context_servers,
+                                    ),
+                                    context_servers: default_profile
+                                        .context_servers
+                                        .into_iter()
+                                        .map(|(server_id, preset)| {
+                                            (
+                                                server_id,
+                                                ContextServerPresetContent {
+                                                    tools: preset.tools,
+                                                },
+                                            )
+                                        })
+                                        .collect(),
+                                });
 
-                    match tool.source {
-                        ToolSource::Native => {
-                            *profile.tools.entry(tool.name).or_default() = is_enabled;
-                        }
-                        ToolSource::ContextServer { id } => {
-                            let preset = profile
-                                .context_servers
-                                .entry(id.clone().into())
-                                .or_default();
-                            *preset.tools.entry(tool.name.clone()).or_default() = is_enabled;
+                        match tool.source {
+                            ToolSource::Native => {
+                                *profile.tools.entry(tool.name).or_default() = is_enabled;
+                            }
+                            ToolSource::ContextServer { id } => {
+                                let preset = profile
+                                    .context_servers
+                                    .entry(id.clone().into())
+                                    .or_default();
+                                *preset.tools.entry(tool.name.clone()).or_default() = is_enabled;
+                            }
                         }
                     }
                 }

crates/agent/src/assistant_model_selector.rs

@@ -9,10 +9,17 @@ use settings::update_settings_file;
 use std::sync::Arc;
 use ui::{ButtonLike, PopoverMenuHandle, Tooltip, prelude::*};
 
+#[derive(Clone, Copy)]
+pub enum ModelType {
+    Default,
+    InlineAssistant,
+}
+
 pub struct AssistantModelSelector {
     selector: Entity<LanguageModelSelector>,
     menu_handle: PopoverMenuHandle<LanguageModelSelector>,
     focus_handle: FocusHandle,
+    model_type: ModelType,
 }
 
 impl AssistantModelSelector {
@@ -20,6 +27,7 @@ impl AssistantModelSelector {
         fs: Arc<dyn Fs>,
         menu_handle: PopoverMenuHandle<LanguageModelSelector>,
         focus_handle: FocusHandle,
+        model_type: ModelType,
         window: &mut Window,
         cx: &mut App,
     ) -> Self {
@@ -28,11 +36,32 @@ impl AssistantModelSelector {
                 let fs = fs.clone();
                 LanguageModelSelector::new(
                     move |model, cx| {
-                        update_settings_file::<AssistantSettings>(
-                            fs.clone(),
-                            cx,
-                            move |settings, _cx| settings.set_model(model.clone()),
-                        );
+                        let provider = model.provider_id().0.to_string();
+                        let model_id = model.id().0.to_string();
+
+                        match model_type {
+                            ModelType::Default => {
+                                update_settings_file::<AssistantSettings>(
+                                    fs.clone(),
+                                    cx,
+                                    move |settings, _cx| {
+                                        settings.set_model(model.clone());
+                                    },
+                                );
+                            }
+                            ModelType::InlineAssistant => {
+                                update_settings_file::<AssistantSettings>(
+                                    fs.clone(),
+                                    cx,
+                                    move |settings, _cx| {
+                                        settings.set_inline_assistant_model(
+                                            provider.clone(),
+                                            model_id.clone(),
+                                        );
+                                    },
+                                );
+                            }
+                        }
                     },
                     window,
                     cx,
@@ -40,6 +69,7 @@ impl AssistantModelSelector {
             }),
             menu_handle,
             focus_handle,
+            model_type,
         }
     }
 
@@ -50,11 +80,16 @@ impl AssistantModelSelector {
 
 impl Render for AssistantModelSelector {
     fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let active_model = LanguageModelRegistry::read_global(cx).active_model();
         let focus_handle = self.focus_handle.clone();
-        let model_name = match active_model {
-            Some(model) => model.name().0,
-            _ => SharedString::from("No model selected"),
+
+        let model_registry = LanguageModelRegistry::read_global(cx);
+        let model = match self.model_type {
+            ModelType::Default => model_registry.default_model(),
+            ModelType::InlineAssistant => model_registry.inline_assistant_model(),
+        };
+        let (model_name, model_icon) = match model {
+            Some(model) => (model.model.name().0, Some(model.provider.icon())),
+            _ => (SharedString::from("No model selected"), None),
         };
 
         LanguageModelSelectorPopoverMenu::new(
@@ -64,10 +99,16 @@ impl Render for AssistantModelSelector {
                 .child(
                     h_flex()
                         .gap_0p5()
+                        .children(
+                            model_icon.map(|icon| {
+                                Icon::new(icon).color(Color::Muted).size(IconSize::Small)
+                            }),
+                        )
                         .child(
                             Label::new(model_name)
                                 .size(LabelSize::Small)
-                                .color(Color::Muted),
+                                .color(Color::Muted)
+                                .ml_1(),
                         )
                         .child(
                             Icon::new(IconName::ChevronDown)

crates/agent/src/assistant_panel.rs

@@ -1,5 +1,6 @@
 use std::path::PathBuf;
 use std::sync::Arc;
+use std::time::Duration;
 
 use anyhow::{Result, anyhow};
 use assistant_context_editor::{
@@ -11,12 +12,12 @@ use assistant_slash_command::SlashCommandWorkingSet;
 use assistant_tool::ToolWorkingSet;
 
 use client::zed_urls;
-use editor::{Editor, MultiBuffer};
+use editor::{Editor, EditorEvent, MultiBuffer};
 use fs::Fs;
 use gpui::{
-    Action, AnyElement, App, AsyncWindowContext, Corner, Entity, EventEmitter, FocusHandle,
-    Focusable, FontWeight, KeyContext, Pixels, Subscription, Task, UpdateGlobal, WeakEntity,
-    action_with_deprecated_aliases, prelude::*,
+    Action, Animation, AnimationExt as _, AnyElement, App, AsyncWindowContext, Corner, Entity,
+    EventEmitter, FocusHandle, Focusable, FontWeight, KeyContext, Pixels, Subscription, Task,
+    UpdateGlobal, WeakEntity, prelude::*, pulsating_between,
 };
 use language::LanguageRegistry;
 use language_model::{LanguageModelProviderTosView, LanguageModelRegistry};
@@ -32,26 +33,21 @@ use ui::{
 use util::ResultExt as _;
 use workspace::Workspace;
 use workspace::dock::{DockPosition, Panel, PanelEvent};
-use zed_actions::assistant::ToggleFocus;
+use zed_actions::agent::OpenConfiguration;
+use zed_actions::assistant::{OpenPromptLibrary, ToggleFocus};
 
 use crate::active_thread::ActiveThread;
 use crate::assistant_configuration::{AssistantConfiguration, AssistantConfigurationEvent};
 use crate::history_store::{HistoryEntry, HistoryStore};
 use crate::message_editor::MessageEditor;
-use crate::thread::{Thread, ThreadError, ThreadId};
+use crate::thread::{Thread, ThreadError, ThreadId, TokenUsageRatio};
 use crate::thread_history::{PastContext, PastThread, ThreadHistory};
 use crate::thread_store::ThreadStore;
 use crate::{
-    AgentDiff, InlineAssistant, NewPromptEditor, NewThread, OpenActiveThreadAsMarkdown,
-    OpenAgentDiff, OpenConfiguration, OpenHistory, ToggleContextPicker,
+    AgentDiff, ExpandMessageEditor, InlineAssistant, NewTextThread, NewThread,
+    OpenActiveThreadAsMarkdown, OpenAgentDiff, OpenHistory, ThreadEvent, ToggleContextPicker,
 };
 
-action_with_deprecated_aliases!(
-    assistant,
-    OpenPromptLibrary,
-    ["assistant::DeployPromptLibrary"]
-);
-
 pub fn init(cx: &mut App) {
     cx.observe_new(
         |workspace: &mut Workspace, _window, _cx: &mut Context<Workspace>| {
@@ -74,7 +70,7 @@ pub fn init(cx: &mut App) {
                         panel.update(cx, |panel, cx| panel.open_configuration(window, cx));
                     }
                 })
-                .register_action(|workspace, _: &NewPromptEditor, window, cx| {
+                .register_action(|workspace, _: &NewTextThread, window, cx| {
                     if let Some(panel) = workspace.panel::<AssistantPanel>(cx) {
                         workspace.focus_panel::<AssistantPanel>(window, cx);
                         panel.update(cx, |panel, cx| panel.new_prompt_editor(window, cx));
@@ -89,10 +85,19 @@ pub fn init(cx: &mut App) {
                     }
                 })
                 .register_action(|workspace, _: &OpenAgentDiff, window, cx| {
+                    if let Some(panel) = workspace.panel::<AssistantPanel>(cx) {
+                        workspace.focus_panel::<AssistantPanel>(window, cx);
+                        let thread = panel.read(cx).thread.read(cx).thread().clone();
+                        AgentDiff::deploy_in_workspace(thread, workspace, window, cx);
+                    }
+                })
+                .register_action(|workspace, _: &ExpandMessageEditor, window, cx| {
                     if let Some(panel) = workspace.panel::<AssistantPanel>(cx) {
                         workspace.focus_panel::<AssistantPanel>(window, cx);
                         panel.update(cx, |panel, cx| {
-                            panel.open_agent_diff(&OpenAgentDiff, window, cx);
+                            panel.message_editor.update(cx, |editor, cx| {
+                                editor.expand_message_editor(&ExpandMessageEditor, window, cx);
+                            });
                         });
                     }
                 });
@@ -102,12 +107,72 @@ pub fn init(cx: &mut App) {
 }
 
 enum ActiveView {
-    Thread,
+    Thread {
+        change_title_editor: Entity<Editor>,
+        _subscriptions: Vec<gpui::Subscription>,
+    },
     PromptEditor,
     History,
     Configuration,
 }
 
+impl ActiveView {
+    pub fn thread(thread: Entity<Thread>, window: &mut Window, cx: &mut App) -> Self {
+        let summary = thread.read(cx).summary_or_default();
+
+        let editor = cx.new(|cx| {
+            let mut editor = Editor::single_line(window, cx);
+            editor.set_text(summary, window, cx);
+            editor
+        });
+
+        let subscriptions = vec![
+            window.subscribe(&editor, cx, {
+                {
+                    let thread = thread.clone();
+                    move |editor, event, window, cx| match event {
+                        EditorEvent::BufferEdited => {
+                            let new_summary = editor.read(cx).text(cx);
+
+                            thread.update(cx, |thread, cx| {
+                                thread.set_summary(new_summary, cx);
+                            })
+                        }
+                        EditorEvent::Blurred => {
+                            if editor.read(cx).text(cx).is_empty() {
+                                let summary = thread.read(cx).summary_or_default();
+
+                                editor.update(cx, |editor, cx| {
+                                    editor.set_text(summary, window, cx);
+                                });
+                            }
+                        }
+                        _ => {}
+                    }
+                }
+            }),
+            window.subscribe(&thread, cx, {
+                let editor = editor.clone();
+                move |thread, event, window, cx| match event {
+                    ThreadEvent::SummaryGenerated => {
+                        let summary = thread.read(cx).summary_or_default();
+
+                        editor.update(cx, |editor, cx| {
+                            editor.set_text(summary, window, cx);
+                        })
+                    }
+                    _ => {}
+                }
+            }),
+        ];
+
+        Self::Thread {
+            change_title_editor: editor,
+            _subscriptions: subscriptions,
+        }
+    }
+}
+
 pub struct AssistantPanel {
     workspace: WeakEntity<Workspace>,
     project: Entity<Project>,
@@ -115,6 +180,7 @@ pub struct AssistantPanel {
     language_registry: Arc<LanguageRegistry>,
     thread_store: Entity<ThreadStore>,
     thread: Entity<ActiveThread>,
+    _thread_subscription: Subscription,
     message_editor: Entity<MessageEditor>,
     context_store: Entity<assistant_context_editor::ContextStore>,
     context_editor: Option<Entity<ContextEditor>>,
@@ -122,6 +188,7 @@ pub struct AssistantPanel {
     configuration_subscription: Option<Subscription>,
     local_timezone: UtcOffset,
     active_view: ActiveView,
+    previous_view: Option<ActiveView>,
     history_store: Entity<HistoryStore>,
     history: Entity<ThreadHistory>,
     assistant_dropdown_menu_handle: PopoverMenuHandle<ContextMenu>,
@@ -137,10 +204,12 @@ impl AssistantPanel {
     ) -> Task<Result<Entity<Self>>> {
         cx.spawn(async move |cx| {
             let tools = Arc::new(ToolWorkingSet::default());
-            let thread_store = workspace.update(cx, |workspace, cx| {
-                let project = workspace.project().clone();
-                ThreadStore::new(project, tools.clone(), prompt_builder.clone(), cx)
-            })??;
+            let thread_store = workspace
+                .update(cx, |workspace, cx| {
+                    let project = workspace.project().clone();
+                    ThreadStore::load(project, tools.clone(), prompt_builder.clone(), cx)
+                })?
+                .await;
 
             let slash_commands = Arc::new(SlashCommandWorkingSet::default());
             let context_store = workspace
@@ -170,14 +239,14 @@ impl AssistantPanel {
     ) -> Self {
         let thread = thread_store.update(cx, |this, cx| this.create_thread(cx));
         let fs = workspace.app_state().fs.clone();
-        let project = workspace.project().clone();
+        let project = workspace.project();
         let language_registry = project.read(cx).languages().clone();
         let workspace = workspace.weak_handle();
         let weak_self = cx.entity().downgrade();
 
         let message_editor_context_store = cx.new(|_cx| {
             crate::context_store::ContextStore::new(
-                workspace.clone(),
+                project.downgrade(),
                 Some(thread_store.downgrade()),
             )
         });
@@ -197,6 +266,15 @@ impl AssistantPanel {
         let history_store =
             cx.new(|cx| HistoryStore::new(thread_store.clone(), context_store.clone(), cx));
 
+        cx.observe(&history_store, |_, _, cx| cx.notify()).detach();
+
+        let active_view = ActiveView::thread(thread.clone(), window, cx);
+        let thread_subscription = cx.subscribe(&thread, |_, _, event, cx| {
+            if let ThreadEvent::MessageAdded(_) = &event {
+                // needed to leave empty state
+                cx.notify();
+            }
+        });
         let thread = cx.new(|cx| {
             ActiveThread::new(
                 thread.clone(),
@@ -210,13 +288,14 @@ impl AssistantPanel {
         });
 
         Self {
-            active_view: ActiveView::Thread,
+            active_view,
             workspace,
             project: project.clone(),
             fs: fs.clone(),
             language_registry,
             thread_store: thread_store.clone(),
             thread,
+            _thread_subscription: thread_subscription,
             message_editor,
             context_store,
             context_editor: None,
@@ -226,8 +305,9 @@ impl AssistantPanel {
                 chrono::Local::now().offset().local_minus_utc(),
             )
             .unwrap(),
+            previous_view: None,
             history_store: history_store.clone(),
-            history: cx.new(|cx| ThreadHistory::new(weak_self, history_store, cx)),
+            history: cx.new(|cx| ThreadHistory::new(weak_self, history_store, window, cx)),
             assistant_dropdown_menu_handle: PopoverMenuHandle::default(),
             width: None,
             height: None,
@@ -271,11 +351,12 @@ impl AssistantPanel {
             .thread_store
             .update(cx, |this, cx| this.create_thread(cx));
 
-        self.active_view = ActiveView::Thread;
+        let thread_view = ActiveView::thread(thread.clone(), window, cx);
+        self.set_active_view(thread_view, window, cx);
 
         let message_editor_context_store = cx.new(|_cx| {
             crate::context_store::ContextStore::new(
-                self.workspace.clone(),
+                self.project.downgrade(),
                 Some(self.thread_store.downgrade()),
             )
         });
@@ -311,6 +392,14 @@ impl AssistantPanel {
                 cx,
             )
         });
+
+        self._thread_subscription = cx.subscribe(&thread, |_, _, event, cx| {
+            if let ThreadEvent::MessageAdded(_) = &event {
+                // needed to leave empty state
+                cx.notify();
+            }
+        });
+
         self.message_editor = cx.new(|cx| {
             MessageEditor::new(
                 self.fs.clone(),
@@ -326,7 +415,7 @@ impl AssistantPanel {
     }
 
     fn new_prompt_editor(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        self.active_view = ActiveView::PromptEditor;
+        self.set_active_view(ActiveView::PromptEditor, window, cx);
 
         let context = self
             .context_store
@@ -376,11 +465,16 @@ impl AssistantPanel {
     }
 
     fn open_history(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        self.thread_store
-            .update(cx, |thread_store, cx| thread_store.reload(cx))
-            .detach_and_log_err(cx);
-        self.active_view = ActiveView::History;
-        self.history.focus_handle(cx).focus(window);
+        if matches!(self.active_view, ActiveView::History) {
+            if let Some(previous_view) = self.previous_view.take() {
+                self.set_active_view(previous_view, window, cx);
+            }
+        } else {
+            self.thread_store
+                .update(cx, |thread_store, cx| thread_store.reload(cx))
+                .detach_and_log_err(cx);
+            self.set_active_view(ActiveView::History, window, cx);
+        }
         cx.notify();
     }
 
@@ -413,7 +507,7 @@ impl AssistantPanel {
                         cx,
                     )
                 });
-                this.active_view = ActiveView::PromptEditor;
+                this.set_active_view(ActiveView::PromptEditor, window, cx);
                 this.context_editor = Some(editor);
 
                 anyhow::Ok(())
@@ -435,10 +529,11 @@ impl AssistantPanel {
         cx.spawn_in(window, async move |this, cx| {
             let thread = open_thread_task.await?;
             this.update_in(cx, |this, window, cx| {
-                this.active_view = ActiveView::Thread;
+                let thread_view = ActiveView::thread(thread.clone(), window, cx);
+                this.set_active_view(thread_view, window, cx);
                 let message_editor_context_store = cx.new(|_cx| {
                     crate::context_store::ContextStore::new(
-                        this.workspace.clone(),
+                        this.project.downgrade(),
                         Some(this.thread_store.downgrade()),
                     )
                 });
@@ -469,6 +564,18 @@ impl AssistantPanel {
         })
     }
 
+    pub fn go_back(&mut self, _: &workspace::GoBack, window: &mut Window, cx: &mut Context<Self>) {
+        match self.active_view {
+            ActiveView::Configuration | ActiveView::History => {
+                self.active_view =
+                    ActiveView::thread(self.thread.read(cx).thread().clone(), window, cx);
+                self.message_editor.focus_handle(cx).focus(window);
+                cx.notify();
+            }
+            _ => {}
+        }
+    }
+
     pub fn open_agent_diff(
         &mut self,
         _: &OpenAgentDiff,
@@ -476,7 +583,11 @@ impl AssistantPanel {
         cx: &mut Context<Self>,
     ) {
         let thread = self.thread.read(cx).thread().clone();
-        AgentDiff::deploy(thread, self.workspace.clone(), window, cx).log_err();
+        self.workspace
+            .update(cx, |workspace, cx| {
+                AgentDiff::deploy_in_workspace(thread, workspace, window, cx)
+            })
+            .log_err();
     }
 
     pub(crate) fn open_configuration(&mut self, window: &mut Window, cx: &mut Context<Self>) {
@@ -484,7 +595,7 @@ impl AssistantPanel {
         let tools = self.thread_store.read(cx).tools();
         let fs = self.fs.clone();
 
-        self.active_view = ActiveView::Configuration;
+        self.set_active_view(ActiveView::Configuration, window, cx);
         self.configuration =
             Some(cx.new(|cx| {
                 AssistantConfiguration::new(fs, context_server_manager, tools, window, cx)
@@ -570,10 +681,8 @@ impl AssistantPanel {
         match event {
             AssistantConfigurationEvent::NewThread(provider) => {
                 if LanguageModelRegistry::read_global(cx)
-                    .active_provider()
-                    .map_or(true, |active_provider| {
-                        active_provider.id() != provider.id()
-                    })
+                    .default_model()
+                    .map_or(true, |model| model.provider.id() != provider.id())
                 {
                     if let Some(model) = provider.default_model(cx) {
                         update_settings_file::<AssistantSettings>(
@@ -593,27 +702,56 @@ impl AssistantPanel {
         self.thread.read(cx).thread().clone()
     }
 
-    pub(crate) fn delete_thread(&mut self, thread_id: &ThreadId, cx: &mut Context<Self>) {
+    pub(crate) fn delete_thread(
+        &mut self,
+        thread_id: &ThreadId,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<()>> {
         self.thread_store
             .update(cx, |this, cx| this.delete_thread(thread_id, cx))
-            .detach_and_log_err(cx);
     }
 
     pub(crate) fn active_context_editor(&self) -> Option<Entity<ContextEditor>> {
         self.context_editor.clone()
     }
 
-    pub(crate) fn delete_context(&mut self, path: PathBuf, cx: &mut Context<Self>) {
+    pub(crate) fn delete_context(
+        &mut self,
+        path: PathBuf,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<()>> {
         self.context_store
             .update(cx, |this, cx| this.delete_local_context(path, cx))
-            .detach_and_log_err(cx);
+    }
+
+    fn set_active_view(
+        &mut self,
+        new_view: ActiveView,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let current_is_history = matches!(self.active_view, ActiveView::History);
+        let new_is_history = matches!(new_view, ActiveView::History);
+
+        if current_is_history && !new_is_history {
+            self.active_view = new_view;
+        } else if !current_is_history && new_is_history {
+            self.previous_view = Some(std::mem::replace(&mut self.active_view, new_view));
+        } else {
+            if !new_is_history {
+                self.previous_view = None;
+            }
+            self.active_view = new_view;
+        }
+
+        self.focus_handle(cx).focus(window);
     }
 }
 
 impl Focusable for AssistantPanel {
     fn focus_handle(&self, cx: &App) -> FocusHandle {
         match self.active_view {
-            ActiveView::Thread => self.message_editor.focus_handle(cx),
+            ActiveView::Thread { .. } => self.message_editor.focus_handle(cx),
             ActiveView::History => self.history.focus_handle(cx),
             ActiveView::PromptEditor => {
                 if let Some(context_editor) = self.context_editor.as_ref() {
@@ -714,70 +852,197 @@ impl Panel for AssistantPanel {
 }
 
 impl AssistantPanel {
-    fn render_toolbar(&self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let thread = self.thread.read(cx);
-        let is_empty = thread.is_empty();
+    fn render_title_view(&self, _window: &mut Window, cx: &mut Context<Self>) -> AnyElement {
+        const LOADING_SUMMARY_PLACEHOLDER: &str = "Loading Summary…";
 
-        let thread_id = thread.thread().read(cx).id().clone();
-        let focus_handle = self.focus_handle(cx);
+        let content = match &self.active_view {
+            ActiveView::Thread {
+                change_title_editor,
+                ..
+            } => {
+                let active_thread = self.thread.read(cx);
+                let is_empty = active_thread.is_empty();
+
+                let summary = active_thread.summary(cx);
 
-        let title = match self.active_view {
-            ActiveView::Thread => {
                 if is_empty {
-                    thread.summary_or_default(cx)
+                    Label::new(Thread::DEFAULT_SUMMARY.clone())
+                        .truncate()
+                        .ml_2()
+                        .into_any_element()
+                } else if summary.is_none() {
+                    Label::new(LOADING_SUMMARY_PLACEHOLDER)
+                        .ml_2()
+                        .truncate()
+                        .into_any_element()
                 } else {
-                    thread
-                        .summary(cx)
-                        .unwrap_or_else(|| SharedString::from("Loading Summary…"))
+                    div()
+                        .ml_2()
+                        .w_full()
+                        .child(change_title_editor.clone())
+                        .into_any_element()
                 }
             }
-            ActiveView::PromptEditor => self
-                .context_editor
-                .as_ref()
-                .map(|context_editor| {
-                    SharedString::from(context_editor.read(cx).title(cx).to_string())
-                })
-                .unwrap_or_else(|| SharedString::from("Loading Summary…")),
-            ActiveView::History => "History".into(),
-            ActiveView::Configuration => "Settings".into(),
+            ActiveView::PromptEditor => {
+                let title = self
+                    .context_editor
+                    .as_ref()
+                    .map(|context_editor| {
+                        SharedString::from(context_editor.read(cx).title(cx).to_string())
+                    })
+                    .unwrap_or_else(|| SharedString::from(LOADING_SUMMARY_PLACEHOLDER));
+
+                Label::new(title).ml_2().truncate().into_any_element()
+            }
+            ActiveView::History => Label::new("History").truncate().into_any_element(),
+            ActiveView::Configuration => Label::new("Settings").truncate().into_any_element(),
+        };
+
+        h_flex()
+            .key_context("TitleEditor")
+            .id("TitleEditor")
+            .flex_grow()
+            .w_full()
+            .max_w_full()
+            .overflow_x_scroll()
+            .child(content)
+            .into_any()
+    }
+
+    fn render_toolbar(&self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let active_thread = self.thread.read(cx);
+        let thread = active_thread.thread().read(cx);
+        let token_usage = thread.total_token_usage(cx);
+        let thread_id = thread.id().clone();
+
+        let is_generating = thread.is_generating();
+        let is_empty = active_thread.is_empty();
+        let focus_handle = self.focus_handle(cx);
+
+        let is_history = matches!(self.active_view, ActiveView::History);
+
+        let show_token_count = match &self.active_view {
+            ActiveView::Thread { .. } => !is_empty,
+            ActiveView::PromptEditor => self.context_editor.is_some(),
+            _ => false,
+        };
+
+        let go_back_button = match &self.active_view {
+            ActiveView::History | ActiveView::Configuration => Some(
+                div().pl_1().child(
+                    IconButton::new("go-back", IconName::ArrowLeft)
+                        .icon_size(IconSize::Small)
+                        .on_click(cx.listener(|this, _, window, cx| {
+                            this.go_back(&workspace::GoBack, window, cx);
+                        }))
+                        .tooltip({
+                            let focus_handle = focus_handle.clone();
+                            move |window, cx| {
+                                Tooltip::for_action_in(
+                                    "Go Back",
+                                    &workspace::GoBack,
+                                    &focus_handle,
+                                    window,
+                                    cx,
+                                )
+                            }
+                        }),
+                ),
+            ),
+            _ => None,
         };
 
         h_flex()
             .id("assistant-toolbar")
             .h(Tab::container_height(cx))
+            .max_w_full()
             .flex_none()
             .justify_between()
-            .gap(DynamicSpacing::Base08.rems(cx))
+            .gap_2()
             .bg(cx.theme().colors().tab_bar_background)
             .border_b_1()
             .border_color(cx.theme().colors().border)
             .child(
-                div()
-                    .id("title")
-                    .overflow_x_scroll()
-                    .px(DynamicSpacing::Base08.rems(cx))
-                    .child(Label::new(title).truncate()),
+                h_flex()
+                    .w_full()
+                    .gap_1()
+                    .children(go_back_button)
+                    .child(self.render_title_view(window, cx)),
             )
             .child(
                 h_flex()
                     .h_full()
-                    .pl_2()
                     .gap_2()
-                    .bg(cx.theme().colors().tab_bar_background)
-                    .children(if matches!(self.active_view, ActiveView::PromptEditor) {
-                        self.context_editor
-                            .as_ref()
-                            .and_then(|editor| render_remaining_tokens(editor, cx))
-                    } else {
-                        None
+                    .when(show_token_count, |parent| match self.active_view {
+                        ActiveView::Thread { .. } => {
+                            if token_usage.total == 0 {
+                                return parent;
+                            }
+
+                            let token_color = match token_usage.ratio {
+                                TokenUsageRatio::Normal => Color::Muted,
+                                TokenUsageRatio::Warning => Color::Warning,
+                                TokenUsageRatio::Exceeded => Color::Error,
+                            };
+
+                            parent.child(
+                                h_flex()
+                                    .flex_shrink_0()
+                                    .gap_0p5()
+                                    .child(
+                                        Label::new(assistant_context_editor::humanize_token_count(
+                                            token_usage.total,
+                                        ))
+                                        .size(LabelSize::Small)
+                                        .color(token_color)
+                                        .map(|label| {
+                                            if is_generating {
+                                                label
+                                                    .with_animation(
+                                                        "used-tokens-label",
+                                                        Animation::new(Duration::from_secs(2))
+                                                            .repeat()
+                                                            .with_easing(pulsating_between(
+                                                                0.6, 1.,
+                                                            )),
+                                                        |label, delta| label.alpha(delta),
+                                                    )
+                                                    .into_any()
+                                            } else {
+                                                label.into_any_element()
+                                            }
+                                        }),
+                                    )
+                                    .child(
+                                        Label::new("/").size(LabelSize::Small).color(Color::Muted),
+                                    )
+                                    .child(
+                                        Label::new(assistant_context_editor::humanize_token_count(
+                                            token_usage.max,
+                                        ))
+                                        .size(LabelSize::Small)
+                                        .color(Color::Muted),
+                                    ),
+                            )
+                        }
+                        ActiveView::PromptEditor => {
+                            let Some(editor) = self.context_editor.as_ref() else {
+                                return parent;
+                            };
+                            let Some(element) = render_remaining_tokens(editor, cx) else {
+                                return parent;
+                            };
+                            parent.child(element)
+                        }
+                        _ => parent,
                     })
                     .child(
                         h_flex()
                             .h_full()
+                            .gap(DynamicSpacing::Base02.rems(cx))
                             .px(DynamicSpacing::Base08.rems(cx))
                             .border_l_1()
                             .border_color(cx.theme().colors().border)
-                            .gap(DynamicSpacing::Base02.rems(cx))
                             .child(
                                 IconButton::new("new", IconName::Plus)
                                     .icon_size(IconSize::Small)
@@ -798,6 +1063,27 @@ impl AssistantPanel {
                                         );
                                     }),
                             )
+                            .child(
+                                IconButton::new("open-history", IconName::HistoryRerun)
+                                    .icon_size(IconSize::Small)
+                                    .toggle_state(is_history)
+                                    .selected_icon_color(Color::Accent)
+                                    .tooltip({
+                                        let focus_handle = self.focus_handle(cx);
+                                        move |window, cx| {
+                                            Tooltip::for_action_in(
+                                                "History",
+                                                &OpenHistory,
+                                                &focus_handle,
+                                                window,
+                                                cx,
+                                            )
+                                        }
+                                    })
+                                    .on_click(move |_event, window, cx| {
+                                        window.dispatch_action(OpenHistory.boxed_clone(), cx);
+                                    }),
+                            )
                             .child(
                                 PopoverMenu::new("assistant-menu")
                                     .trigger_with_tooltip(
@@ -813,27 +1099,30 @@ impl AssistantPanel {
                                             window,
                                             cx,
                                             |menu, _window, _cx| {
-                                                menu.action(
-                                                    "New Thread",
-                                                    Box::new(NewThread {
-                                                        from_thread_id: None,
-                                                    }),
+                                                menu
+                                                    .when(!is_empty, |menu| {
+                                                        menu.action(
+                                                            "Start New From Summary",
+                                                            Box::new(NewThread {
+                                                                from_thread_id: Some(thread_id.clone()),
+                                                            }),
+                                                        ).separator()
+                                                    })
+                                                    .action(
+                                                    "New Text Thread",
+                                                    NewTextThread.boxed_clone(),
                                                 )
-                                                .action(
-                                                    "New Prompt Editor",
-                                                    NewPromptEditor.boxed_clone(),
-                                                )
-                                                .when(!is_empty, |menu| {
-                                                    menu.action(
-                                                        "Continue in New Thread",
-                                                        Box::new(NewThread {
-                                                            from_thread_id: Some(thread_id.clone()),
-                                                        }),
-                                                    )
-                                                })
-                                                .separator()
-                                                .action("History", OpenHistory.boxed_clone())
                                                 .action("Settings", OpenConfiguration.boxed_clone())
+                                                .separator()
+                                                .action(
+                                                    "Install MCPs",
+                                                    zed_actions::Extensions {
+                                                        category_filter: Some(
+                                                            zed_actions::ExtensionCategoryFilter::ContextServers,
+                                                        ),
+                                                    }
+                                                    .boxed_clone(),
+                                                )
                                             },
                                         ))
                                     }),
@@ -857,16 +1146,18 @@ impl AssistantPanel {
     }
 
     fn configuration_error(&self, cx: &App) -> Option<ConfigurationError> {
-        let Some(provider) = LanguageModelRegistry::read_global(cx).active_provider() else {
+        let Some(model) = LanguageModelRegistry::read_global(cx).default_model() else {
             return Some(ConfigurationError::NoProvider);
         };
 
-        if !provider.is_authenticated(cx) {
+        if !model.provider.is_authenticated(cx) {
             return Some(ConfigurationError::ProviderNotAuthenticated);
         }
 
-        if provider.must_accept_terms(cx) {
-            return Some(ConfigurationError::ProviderPendingTermsAcceptance(provider));
+        if model.provider.must_accept_terms(cx) {
+            return Some(ConfigurationError::ProviderPendingTermsAcceptance(
+                model.provider,
+            ));
         }
 
         None
@@ -1028,6 +1319,7 @@ impl AssistantPanel {
                 let configuration_error_ref = &configuration_error;
 
                 parent
+                    .overflow_hidden()
                     .p_1p5()
                     .justify_end()
                     .gap_1()
@@ -1069,11 +1361,11 @@ impl AssistantPanel {
                                     // TODO: Add keyboard navigation.
                                     match entry {
                                         HistoryEntry::Thread(thread) => {
-                                            PastThread::new(thread, cx.entity().downgrade(), false)
+                                            PastThread::new(thread, cx.entity().downgrade(), false, vec![])
                                                 .into_any_element()
                                         }
                                         HistoryEntry::Context(context) => {
-                                            PastContext::new(context, cx.entity().downgrade(), false)
+                                            PastContext::new(context, cx.entity().downgrade(), false, vec![])
                                                 .into_any_element()
                                         }
                                     }
@@ -1327,9 +1619,10 @@ impl Render for AssistantPanel {
             .on_action(cx.listener(Self::open_active_thread_as_markdown))
             .on_action(cx.listener(Self::deploy_prompt_library))
             .on_action(cx.listener(Self::open_agent_diff))
+            .on_action(cx.listener(Self::go_back))
             .child(self.render_toolbar(window, cx))
             .map(|parent| match self.active_view {
-                ActiveView::Thread => parent
+                ActiveView::Thread { .. } => parent
                     .child(self.render_active_thread_or_empty_state(window, cx))
                     .child(h_flex().child(self.message_editor.clone()))
                     .children(self.render_last_error(cx)),
@@ -1359,7 +1652,21 @@ impl prompt_library::InlineAssistDelegate for PromptLibraryInlineAssist {
         cx: &mut Context<PromptLibrary>,
     ) {
         InlineAssistant::update_global(cx, |assistant, cx| {
-            assistant.assist(&prompt_editor, self.workspace.clone(), None, window, cx)
+            let Some(project) = self
+                .workspace
+                .upgrade()
+                .map(|workspace| workspace.read(cx).project().downgrade())
+            else {
+                return;
+            };
+            assistant.assist(
+                &prompt_editor,
+                self.workspace.clone(),
+                project,
+                None,
+                window,
+                cx,
+            )
         })
     }
 

crates/agent/src/buffer_codegen.rs

@@ -28,7 +28,7 @@ use std::{
     time::Instant,
 };
 use streaming_diff::{CharOperation, LineDiff, LineOperation, StreamingDiff};
-use telemetry_events::{AssistantEvent, AssistantKind, AssistantPhase};
+use telemetry_events::{AssistantEventData, AssistantKind, AssistantPhase};
 
 pub struct BufferCodegen {
     alternatives: Vec<Entity<CodegenAlternative>>,
@@ -156,8 +156,9 @@ impl BufferCodegen {
         }
 
         let primary_model = LanguageModelRegistry::read_global(cx)
-            .active_model()
-            .context("no active model")?;
+            .default_model()
+            .context("no active model")?
+            .model;
 
         for (model, alternative) in iter::once(primary_model)
             .chain(alternative_models)
@@ -600,7 +601,7 @@ impl CodegenAlternative {
 
                         let error_message = result.as_ref().err().map(|error| error.to_string());
                         report_assistant_event(
-                            AssistantEvent {
+                            AssistantEventData {
                                 conversation_id: None,
                                 message_id,
                                 kind: AssistantKind::Inline,

crates/agent/src/context.rs

@@ -1,9 +1,9 @@
-use std::{ops::Range, sync::Arc};
+use std::{ops::Range, path::Path, sync::Arc};
 
 use gpui::{App, Entity, SharedString};
 use language::{Buffer, File};
 use language_model::LanguageModelRequestMessage;
-use project::ProjectPath;
+use project::{ProjectPath, Worktree};
 use serde::{Deserialize, Serialize};
 use text::{Anchor, BufferId};
 use ui::IconName;
@@ -69,10 +69,21 @@ pub struct FileContext {
 #[derive(Debug, Clone)]
 pub struct DirectoryContext {
     pub id: ContextId,
-    pub project_path: ProjectPath,
+    pub worktree: Entity<Worktree>,
+    pub path: Arc<Path>,
+    /// Buffers of the files within the directory.
     pub context_buffers: Vec<ContextBuffer>,
 }
 
+impl DirectoryContext {
+    pub fn project_path(&self, cx: &App) -> ProjectPath {
+        ProjectPath {
+            worktree_id: self.worktree.read(cx).id(),
+            path: self.path.clone(),
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct SymbolContext {
     pub id: ContextId,
@@ -86,12 +97,11 @@ pub struct FetchedUrlContext {
     pub text: SharedString,
 }
 
-// TODO: Model<Thread> holds onto the thread even if the thread is deleted. Can either handle this
-// explicitly or have a WeakModel<Thread> and remove during snapshot.
-
 #[derive(Debug, Clone)]
 pub struct ThreadContext {
     pub id: ContextId,
+    // TODO: Entity<Thread> holds onto the thread even if the thread is deleted. Should probably be
+    // a WeakEntity and handle removal from the UI when it has dropped.
     pub thread: Entity<Thread>,
     pub text: SharedString,
 }
@@ -105,12 +115,11 @@ impl ThreadContext {
     }
 }
 
-// TODO: Model<Buffer> holds onto the buffer even if the file is deleted and closed. Should remove
-// the context from the message editor in this case.
-
 #[derive(Clone)]
 pub struct ContextBuffer {
     pub id: BufferId,
+    // TODO: Entity<Buffer> holds onto the thread even if the thread is deleted. Should probably be
+    // a WeakEntity and handle removal from the UI when it has dropped.
     pub buffer: Entity<Buffer>,
     pub file: Arc<dyn File>,
     pub version: clock::Global,
@@ -146,11 +155,11 @@ pub struct ContextSymbolId {
     pub range: Range<Anchor>,
 }
 
-pub fn attach_context_to_message<'a>(
-    message: &mut LanguageModelRequestMessage,
+/// Formats a collection of contexts into a string representation
+pub fn format_context_as_string<'a>(
     contexts: impl Iterator<Item = &'a AssistantContext>,
     cx: &App,
-) {
+) -> Option<String> {
     let mut file_context = Vec::new();
     let mut directory_context = Vec::new();
     let mut symbol_context = Vec::new();
@@ -167,64 +176,78 @@ pub fn attach_context_to_message<'a>(
         }
     }
 
-    let mut context_chunks = Vec::new();
+    if file_context.is_empty()
+        && directory_context.is_empty()
+        && symbol_context.is_empty()
+        && fetch_context.is_empty()
+        && thread_context.is_empty()
+    {
+        return None;
+    }
+
+    let mut result = String::new();
+    result.push_str("\n<context>\n\
+        The following items were attached by the user. You don't need to use other tools to read them.\n\n");
 
     if !file_context.is_empty() {
-        context_chunks.push("<files>\n");
+        result.push_str("<files>\n");
         for context in file_context {
-            context_chunks.push(&context.context_buffer.text);
+            result.push_str(&context.context_buffer.text);
         }
-        context_chunks.push("\n</files>\n");
+        result.push_str("</files>\n");
     }
 
     if !directory_context.is_empty() {
-        context_chunks.push("<directories>\n");
+        result.push_str("<directories>\n");
         for context in directory_context {
             for context_buffer in &context.context_buffers {
-                context_chunks.push(&context_buffer.text);
+                result.push_str(&context_buffer.text);
             }
         }
-        context_chunks.push("\n</directories>\n");
+        result.push_str("</directories>\n");
     }
 
     if !symbol_context.is_empty() {
-        context_chunks.push("<symbols>\n");
+        result.push_str("<symbols>\n");
         for context in symbol_context {
-            context_chunks.push(&context.context_symbol.text);
+            result.push_str(&context.context_symbol.text);
+            result.push('\n');
         }
-        context_chunks.push("\n</symbols>\n");
+        result.push_str("</symbols>\n");
     }
 
     if !fetch_context.is_empty() {
-        context_chunks.push("<fetched_urls>\n");
+        result.push_str("<fetched_urls>\n");
         for context in &fetch_context {
-            context_chunks.push(&context.url);
-            context_chunks.push(&context.text);
+            result.push_str(&context.url);
+            result.push('\n');
+            result.push_str(&context.text);
+            result.push('\n');
         }
-        context_chunks.push("\n</fetched_urls>\n");
+        result.push_str("</fetched_urls>\n");
     }
 
-    // Need to own the SharedString for summary so that it can be referenced.
-    let mut thread_context_chunks = Vec::new();
     if !thread_context.is_empty() {
-        context_chunks.push("<conversation_threads>\n");
+        result.push_str("<conversation_threads>\n");
         for context in &thread_context {
-            thread_context_chunks.push(context.summary(cx));
-            thread_context_chunks.push(context.text.clone());
+            result.push_str(&context.summary(cx));
+            result.push('\n');
+            result.push_str(&context.text);
+            result.push('\n');
         }
-        context_chunks.push("\n</conversation_threads>\n");
+        result.push_str("</conversation_threads>\n");
     }
 
-    for chunk in &thread_context_chunks {
-        context_chunks.push(chunk);
-    }
+    result.push_str("</context>\n");
+    Some(result)
+}
 
-    if !context_chunks.is_empty() {
-        message.content.push(
-            "\n<context>\n\
-                The following items were attached by the user. You don't need to use other tools to read them.\n\n".into(),
-        );
-        message.content.push(context_chunks.join("\n").into());
-        message.content.push("\n</context>\n".into());
+pub fn attach_context_to_message<'a>(
+    message: &mut LanguageModelRequestMessage,
+    contexts: impl Iterator<Item = &'a AssistantContext>,
+    cx: &App,
+) {
+    if let Some(context_string) = format_context_as_string(contexts, cx) {
+        message.content.push(context_string.into());
     }
 }

crates/agent/src/context_picker.rs

@@ -13,7 +13,8 @@ use editor::display_map::{Crease, FoldId};
 use editor::{Anchor, AnchorRangeExt as _, Editor, ExcerptId, FoldPlaceholder, ToOffset};
 use file_context_picker::render_file_context_entry;
 use gpui::{
-    App, DismissEvent, Empty, Entity, EventEmitter, FocusHandle, Focusable, Task, WeakEntity,
+    App, DismissEvent, Empty, Entity, EventEmitter, FocusHandle, Focusable, Subscription, Task,
+    WeakEntity,
 };
 use multi_buffer::MultiBufferRow;
 use project::{Entry, ProjectPath};
@@ -33,12 +34,6 @@ use crate::context_store::ContextStore;
 use crate::thread::ThreadId;
 use crate::thread_store::ThreadStore;
 
-#[derive(Debug, Clone, Copy)]
-pub enum ConfirmBehavior {
-    KeepOpen,
-    Close,
-}
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum ContextPickerMode {
     File,
@@ -76,7 +71,7 @@ impl ContextPickerMode {
             Self::File => "Files & Directories",
             Self::Symbol => "Symbols",
             Self::Fetch => "Fetch",
-            Self::Thread => "Thread",
+            Self::Thread => "Threads",
         }
     }
 
@@ -104,7 +99,7 @@ pub(super) struct ContextPicker {
     workspace: WeakEntity<Workspace>,
     context_store: WeakEntity<ContextStore>,
     thread_store: Option<WeakEntity<ThreadStore>>,
-    confirm_behavior: ConfirmBehavior,
+    _subscriptions: Vec<Subscription>,
 }
 
 impl ContextPicker {
@@ -112,10 +107,25 @@ impl ContextPicker {
         workspace: WeakEntity<Workspace>,
         thread_store: Option<WeakEntity<ThreadStore>>,
         context_store: WeakEntity<ContextStore>,
-        confirm_behavior: ConfirmBehavior,
         window: &mut Window,
         cx: &mut Context<Self>,
     ) -> Self {
+        let subscriptions = context_store
+            .upgrade()
+            .map(|context_store| {
+                cx.observe(&context_store, |this, _, cx| this.notify_current_picker(cx))
+            })
+            .into_iter()
+            .chain(
+                thread_store
+                    .as_ref()
+                    .and_then(|thread_store| thread_store.upgrade())
+                    .map(|thread_store| {
+                        cx.observe(&thread_store, |this, _, cx| this.notify_current_picker(cx))
+                    }),
+            )
+            .collect::<Vec<Subscription>>();
+
         ContextPicker {
             mode: ContextPickerState::Default(ContextMenu::build(
                 window,
@@ -125,7 +135,7 @@ impl ContextPicker {
             workspace,
             context_store,
             thread_store,
-            confirm_behavior,
+            _subscriptions: subscriptions,
         }
     }
 
@@ -147,37 +157,32 @@ impl ContextPicker {
 
             let modes = supported_context_picker_modes(&self.thread_store);
 
-            let menu = menu
-                .when(has_recent, |menu| {
-                    menu.custom_row(|_, _| {
-                        div()
-                            .mb_1()
-                            .child(
-                                Label::new("Recent")
-                                    .color(Color::Muted)
-                                    .size(LabelSize::Small),
-                            )
-                            .into_any_element()
-                    })
+            menu.when(has_recent, |menu| {
+                menu.custom_row(|_, _| {
+                    div()
+                        .mb_1()
+                        .child(
+                            Label::new("Recent")
+                                .color(Color::Muted)
+                                .size(LabelSize::Small),
+                        )
+                        .into_any_element()
                 })
-                .extend(recent_entries)
-                .when(has_recent, |menu| menu.separator())
-                .extend(modes.into_iter().map(|mode| {
-                    let context_picker = context_picker.clone();
+            })
+            .extend(recent_entries)
+            .when(has_recent, |menu| menu.separator())
+            .extend(modes.into_iter().map(|mode| {
+                let context_picker = context_picker.clone();
 
-                    ContextMenuEntry::new(mode.label())
-                        .icon(mode.icon())
-                        .icon_size(IconSize::XSmall)
-                        .icon_color(Color::Muted)
-                        .handler(move |window, cx| {
-                            context_picker.update(cx, |this, cx| this.select_mode(mode, window, cx))
-                        })
-                }));
-
-            match self.confirm_behavior {
-                ConfirmBehavior::KeepOpen => menu.keep_open_on_confirm(),
-                ConfirmBehavior::Close => menu,
-            }
+                ContextMenuEntry::new(mode.label())
+                    .icon(mode.icon())
+                    .icon_size(IconSize::XSmall)
+                    .icon_color(Color::Muted)
+                    .handler(move |window, cx| {
+                        context_picker.update(cx, |this, cx| this.select_mode(mode, window, cx))
+                    })
+            }))
+            .keep_open_on_confirm()
         });
 
         cx.subscribe(&menu, move |_, _, _: &DismissEvent, cx| {
@@ -208,7 +213,6 @@ impl ContextPicker {
                         context_picker.clone(),
                         self.workspace.clone(),
                         self.context_store.clone(),
-                        self.confirm_behavior,
                         window,
                         cx,
                     )
@@ -220,7 +224,6 @@ impl ContextPicker {
                         context_picker.clone(),
                         self.workspace.clone(),
                         self.context_store.clone(),
-                        self.confirm_behavior,
                         window,
                         cx,
                     )
@@ -232,7 +235,6 @@ impl ContextPicker {
                         context_picker.clone(),
                         self.workspace.clone(),
                         self.context_store.clone(),
-                        self.confirm_behavior,
                         window,
                         cx,
                     )
@@ -245,7 +247,6 @@ impl ContextPicker {
                             thread_store.clone(),
                             context_picker.clone(),
                             self.context_store.clone(),
-                            self.confirm_behavior,
                             window,
                             cx,
                         )
@@ -270,12 +271,14 @@ impl ContextPicker {
                 path_prefix,
             } => {
                 let context_store = self.context_store.clone();
+                let worktree_id = project_path.worktree_id;
                 let path = project_path.path.clone();
 
                 ContextMenuItem::custom_entry(
                     move |_window, cx| {
                         render_file_context_entry(
                             ElementId::NamedInteger("ctx-recent".into(), ix),
+                            worktree_id,
                             &path,
                             &path_prefix,
                             false,
@@ -360,73 +363,25 @@ impl ContextPicker {
     }
 
     fn recent_entries(&self, cx: &mut App) -> Vec<RecentEntry> {
-        let Some(workspace) = self.workspace.upgrade().map(|w| w.read(cx)) else {
+        let Some(workspace) = self.workspace.upgrade() else {
             return vec![];
         };
 
-        let Some(context_store) = self.context_store.upgrade().map(|cs| cs.read(cx)) else {
+        let Some(context_store) = self.context_store.upgrade() else {
             return vec![];
         };
 
-        let mut recent = Vec::with_capacity(6);
+        recent_context_picker_entries(context_store, self.thread_store.clone(), workspace, cx)
+    }
 
-        let mut current_files = context_store.file_paths(cx);
-
-        if let Some(active_path) = active_singleton_buffer_path(&workspace, cx) {
-            current_files.insert(active_path);
+    fn notify_current_picker(&mut self, cx: &mut Context<Self>) {
+        match &self.mode {
+            ContextPickerState::Default(entity) => entity.update(cx, |_, cx| cx.notify()),
+            ContextPickerState::File(entity) => entity.update(cx, |_, cx| cx.notify()),
+            ContextPickerState::Symbol(entity) => entity.update(cx, |_, cx| cx.notify()),
+            ContextPickerState::Fetch(entity) => entity.update(cx, |_, cx| cx.notify()),
+            ContextPickerState::Thread(entity) => entity.update(cx, |_, cx| cx.notify()),
         }
-
-        let project = workspace.project().read(cx);
-
-        recent.extend(
-            workspace
-                .recent_navigation_history_iter(cx)
-                .filter(|(path, _)| !current_files.contains(&path.path.to_path_buf()))
-                .take(4)
-                .filter_map(|(project_path, _)| {
-                    project
-                        .worktree_for_id(project_path.worktree_id, cx)
-                        .map(|worktree| RecentEntry::File {
-                            project_path,
-                            path_prefix: worktree.read(cx).root_name().into(),
-                        })
-                }),
-        );
-
-        let mut current_threads = context_store.thread_ids();
-
-        if let Some(active_thread) = workspace
-            .panel::<AssistantPanel>(cx)
-            .map(|panel| panel.read(cx).active_thread(cx))
-        {
-            current_threads.insert(active_thread.read(cx).id().clone());
-        }
-
-        let Some(thread_store) = self
-            .thread_store
-            .as_ref()
-            .and_then(|thread_store| thread_store.upgrade())
-        else {
-            return recent;
-        };
-
-        thread_store.update(cx, |thread_store, _cx| {
-            recent.extend(
-                thread_store
-                    .threads()
-                    .into_iter()
-                    .filter(|thread| !current_threads.contains(&thread.id))
-                    .take(2)
-                    .map(|thread| {
-                        RecentEntry::Thread(ThreadContextEntry {
-                            id: thread.id,
-                            summary: thread.summary,
-                        })
-                    }),
-            )
-        });
-
-        recent
     }
 }
 
@@ -480,16 +435,6 @@ fn supported_context_picker_modes(
     modes
 }
 
-fn active_singleton_buffer_path(workspace: &Workspace, cx: &App) -> Option<PathBuf> {
-    let active_item = workspace.active_item(cx)?;
-
-    let editor = active_item.to_any().downcast::<Editor>().ok()?.read(cx);
-    let buffer = editor.buffer().read(cx).as_singleton()?;
-
-    let path = buffer.read(cx).file()?.path().to_path_buf();
-    Some(path)
-}
-
 fn recent_context_picker_entries(
     context_store: Entity<ContextStore>,
     thread_store: Option<WeakEntity<ThreadStore>>,
@@ -498,20 +443,14 @@ fn recent_context_picker_entries(
 ) -> Vec<RecentEntry> {
     let mut recent = Vec::with_capacity(6);
 
-    let mut current_files = context_store.read(cx).file_paths(cx);
-
+    let current_files = context_store.read(cx).file_paths(cx);
     let workspace = workspace.read(cx);
-
-    if let Some(active_path) = active_singleton_buffer_path(workspace, cx) {
-        current_files.insert(active_path);
-    }
-
     let project = workspace.project().read(cx);
 
     recent.extend(
         workspace
             .recent_navigation_history_iter(cx)
-            .filter(|(path, _)| !current_files.contains(&path.path.to_path_buf()))
+            .filter(|(path, _)| !current_files.contains(path))
             .take(4)
             .filter_map(|(project_path, _)| {
                 project
@@ -552,14 +491,13 @@ fn recent_context_picker_entries(
     recent
 }
 
-pub(crate) fn insert_crease_for_mention(
+pub(crate) fn insert_fold_for_mention(
     excerpt_id: ExcerptId,
     crease_start: text::Anchor,
     content_len: usize,
     crease_label: SharedString,
     crease_icon_path: SharedString,
     editor_entity: Entity<Editor>,
-    window: &mut Window,
     cx: &mut App,
 ) {
     editor_entity.update(cx, |editor, cx| {
@@ -578,6 +516,7 @@ pub(crate) fn insert_crease_for_mention(
                 crease_label,
                 editor_entity.downgrade(),
             ),
+            merge_adjacent: false,
             ..Default::default()
         };
 
@@ -591,8 +530,9 @@ pub(crate) fn insert_crease_for_mention(
             render_trailer,
         );
 
-        editor.insert_creases(vec![crease.clone()], cx);
-        editor.fold_creases(vec![crease], false, window, cx);
+        editor.display_map.update(cx, |display_map, cx| {
+            display_map.fold(vec![crease], cx);
+        });
     });
 }
 
@@ -649,12 +589,13 @@ fn render_fold_icon_button(
                         .gap_1()
                         .child(
                             Icon::from_path(icon_path.clone())
-                                .size(IconSize::Small)
+                                .size(IconSize::XSmall)
                                 .color(Color::Muted),
                         )
                         .child(
                             Label::new(label.clone())
                                 .size(LabelSize::Small)
+                                .buffer_font(cx)
                                 .single_line(),
                         ),
                 )
@@ -683,24 +624,45 @@ fn fold_toggle(
 pub enum MentionLink {
     File(ProjectPath, Entry),
     Symbol(ProjectPath, String),
+    Fetch(String),
     Thread(ThreadId),
 }
 
 impl MentionLink {
+    const FILE: &str = "@file";
+    const SYMBOL: &str = "@symbol";
+    const THREAD: &str = "@thread";
+    const FETCH: &str = "@fetch";
+
+    const SEPARATOR: &str = ":";
+
+    pub fn is_valid(url: &str) -> bool {
+        url.starts_with(Self::FILE)
+            || url.starts_with(Self::SYMBOL)
+            || url.starts_with(Self::FETCH)
+            || url.starts_with(Self::THREAD)
+    }
+
     pub fn for_file(file_name: &str, full_path: &str) -> String {
-        format!("[@{}](file:{})", file_name, full_path)
+        format!("[@{}]({}:{})", file_name, Self::FILE, full_path)
     }
 
     pub fn for_symbol(symbol_name: &str, full_path: &str) -> String {
-        format!("[@{}](symbol:{}:{})", symbol_name, full_path, symbol_name)
+        format!(
+            "[@{}]({}:{}:{})",
+            symbol_name,
+            Self::SYMBOL,
+            full_path,
+            symbol_name
+        )
     }
 
     pub fn for_fetch(url: &str) -> String {
-        format!("[@{}]({})", url, url)
+        format!("[@{}]({}:{})", url, Self::FETCH, url)
     }
 
     pub fn for_thread(thread: &ThreadContextEntry) -> String {
-        format!("[@{}](thread:{})", thread.summary, thread.id)
+        format!("[@{}]({}:{})", thread.summary, Self::THREAD, thread.id)
     }
 
     pub fn try_parse(link: &str, workspace: &Entity<Workspace>, cx: &App) -> Option<Self> {
@@ -723,17 +685,10 @@ impl MentionLink {
             })
         }
 
-        let (prefix, link, target) = {
-            let mut parts = link.splitn(3, ':');
-            let prefix = parts.next();
-            let link = parts.next();
-            let target = parts.next();
-            (prefix, link, target)
-        };
-
-        match (prefix, link, target) {
-            (Some("file"), Some(path), _) => {
-                let project_path = extract_project_path_from_link(path, workspace, cx)?;
+        let (prefix, argument) = link.split_once(Self::SEPARATOR)?;
+        match prefix {
+            Self::FILE => {
+                let project_path = extract_project_path_from_link(argument, workspace, cx)?;
                 let entry = workspace
                     .read(cx)
                     .project()
@@ -741,14 +696,16 @@ impl MentionLink {
                     .entry_for_path(&project_path, cx)?;
                 Some(MentionLink::File(project_path, entry))
             }
-            (Some("symbol"), Some(path), Some(symbol_name)) => {
+            Self::SYMBOL => {
+                let (path, symbol) = argument.split_once(Self::SEPARATOR)?;
                 let project_path = extract_project_path_from_link(path, workspace, cx)?;
-                Some(MentionLink::Symbol(project_path, symbol_name.to_string()))
+                Some(MentionLink::Symbol(project_path, symbol.to_string()))
             }
-            (Some("thread"), Some(thread_id), _) => {
-                let thread_id = ThreadId::from(thread_id);
+            Self::THREAD => {
+                let thread_id = ThreadId::from(argument);
                 Some(MentionLink::Thread(thread_id))
             }
+            Self::FETCH => Some(MentionLink::Fetch(argument.to_string())),
             _ => None,
         }
     }

crates/agent/src/context_picker/completion_provider.rs

@@ -18,16 +18,133 @@ use text::{Anchor, ToPoint};
 use ui::prelude::*;
 use workspace::Workspace;
 
-use crate::context::AssistantContext;
+use crate::context_picker::file_context_picker::search_files;
+use crate::context_picker::symbol_context_picker::search_symbols;
 use crate::context_store::ContextStore;
 use crate::thread_store::ThreadStore;
 
 use super::fetch_context_picker::fetch_url_content;
-use super::thread_context_picker::ThreadContextEntry;
+use super::file_context_picker::FileMatch;
+use super::symbol_context_picker::SymbolMatch;
+use super::thread_context_picker::{ThreadContextEntry, ThreadMatch, search_threads};
 use super::{
-    ContextPickerMode, MentionLink, recent_context_picker_entries, supported_context_picker_modes,
+    ContextPickerMode, MentionLink, RecentEntry, recent_context_picker_entries,
+    supported_context_picker_modes,
 };
 
+pub(crate) enum Match {
+    Symbol(SymbolMatch),
+    File(FileMatch),
+    Thread(ThreadMatch),
+    Fetch(SharedString),
+    Mode(ContextPickerMode),
+}
+
+fn search(
+    mode: Option<ContextPickerMode>,
+    query: String,
+    cancellation_flag: Arc<AtomicBool>,
+    recent_entries: Vec<RecentEntry>,
+    thread_store: Option<WeakEntity<ThreadStore>>,
+    workspace: Entity<Workspace>,
+    cx: &mut App,
+) -> Task<Vec<Match>> {
+    match mode {
+        Some(ContextPickerMode::File) => {
+            let search_files_task =
+                search_files(query.clone(), cancellation_flag.clone(), &workspace, cx);
+            cx.background_spawn(async move {
+                search_files_task
+                    .await
+                    .into_iter()
+                    .map(Match::File)
+                    .collect()
+            })
+        }
+        Some(ContextPickerMode::Symbol) => {
+            let search_symbols_task =
+                search_symbols(query.clone(), cancellation_flag.clone(), &workspace, cx);
+            cx.background_spawn(async move {
+                search_symbols_task
+                    .await
+                    .into_iter()
+                    .map(Match::Symbol)
+                    .collect()
+            })
+        }
+        Some(ContextPickerMode::Thread) => {
+            if let Some(thread_store) = thread_store.as_ref().and_then(|t| t.upgrade()) {
+                let search_threads_task =
+                    search_threads(query.clone(), cancellation_flag.clone(), thread_store, cx);
+                cx.background_spawn(async move {
+                    search_threads_task
+                        .await
+                        .into_iter()
+                        .map(Match::Thread)
+                        .collect()
+                })
+            } else {
+                Task::ready(Vec::new())
+            }
+        }
+        Some(ContextPickerMode::Fetch) => {
+            if !query.is_empty() {
+                Task::ready(vec![Match::Fetch(query.into())])
+            } else {
+                Task::ready(Vec::new())
+            }
+        }
+        None => {
+            if query.is_empty() {
+                let mut matches = recent_entries
+                    .into_iter()
+                    .map(|entry| match entry {
+                        super::RecentEntry::File {
+                            project_path,
+                            path_prefix,
+                        } => Match::File(FileMatch {
+                            mat: fuzzy::PathMatch {
+                                score: 1.,
+                                positions: Vec::new(),
+                                worktree_id: project_path.worktree_id.to_usize(),
+                                path: project_path.path,
+                                path_prefix,
+                                is_dir: false,
+                                distance_to_relative_ancestor: 0,
+                            },
+                            is_recent: true,
+                        }),
+                        super::RecentEntry::Thread(thread_context_entry) => {
+                            Match::Thread(ThreadMatch {
+                                thread: thread_context_entry,
+                                is_recent: true,
+                            })
+                        }
+                    })
+                    .collect::<Vec<_>>();
+
+                matches.extend(
+                    supported_context_picker_modes(&thread_store)
+                        .into_iter()
+                        .map(Match::Mode),
+                );
+
+                Task::ready(matches)
+            } else {
+                let search_files_task =
+                    search_files(query.clone(), cancellation_flag.clone(), &workspace, cx);
+                cx.background_spawn(async move {
+                    search_files_task
+                        .await
+                        .into_iter()
+                        .map(Match::File)
+                        .collect()
+                })
+            }
+        }
+    }
+}
+
 pub struct ContextPickerCompletionProvider {
     workspace: WeakEntity<Workspace>,
     context_store: WeakEntity<ContextStore>,
@@ -50,96 +167,20 @@ impl ContextPickerCompletionProvider {
         }
     }
 
-    fn default_completions(
-        excerpt_id: ExcerptId,
-        source_range: Range<Anchor>,
-        context_store: Entity<ContextStore>,
-        thread_store: Option<WeakEntity<ThreadStore>>,
-        editor: Entity<Editor>,
-        workspace: Entity<Workspace>,
-        cx: &App,
-    ) -> Vec<Completion> {
-        let mut completions = Vec::new();
-
-        completions.extend(
-            recent_context_picker_entries(
-                context_store.clone(),
-                thread_store.clone(),
-                workspace.clone(),
-                cx,
-            )
-            .iter()
-            .filter_map(|entry| match entry {
-                super::RecentEntry::File {
-                    project_path,
-                    path_prefix,
-                } => Some(Self::completion_for_path(
-                    project_path.clone(),
-                    path_prefix,
-                    true,
-                    false,
-                    excerpt_id,
-                    source_range.clone(),
-                    editor.clone(),
-                    context_store.clone(),
-                    cx,
-                )),
-                super::RecentEntry::Thread(thread_context_entry) => {
-                    let thread_store = thread_store
-                        .as_ref()
-                        .and_then(|thread_store| thread_store.upgrade())?;
-                    Some(Self::completion_for_thread(
-                        thread_context_entry.clone(),
-                        excerpt_id,
-                        source_range.clone(),
-                        true,
-                        editor.clone(),
-                        context_store.clone(),
-                        thread_store,
-                    ))
-                }
-            }),
-        );
-
-        completions.extend(
-            supported_context_picker_modes(&thread_store)
-                .iter()
-                .map(|mode| {
-                    Completion {
-                        old_range: source_range.clone(),
-                        new_text: format!("@{} ", mode.mention_prefix()),
-                        label: CodeLabel::plain(mode.label().to_string(), None),
-                        icon_path: Some(mode.icon().path().into()),
-                        documentation: None,
-                        source: project::CompletionSource::Custom,
-                        // This ensures that when a user accepts this completion, the
-                        // completion menu will still be shown after "@category " is
-                        // inserted
-                        confirm: Some(Arc::new(|_, _, _| true)),
-                    }
-                }),
-        );
-        completions
-    }
-
-    fn build_code_label_for_full_path(
-        file_name: &str,
-        directory: Option<&str>,
-        cx: &App,
-    ) -> CodeLabel {
-        let comment_id = cx.theme().syntax().highlight_id("comment").map(HighlightId);
-        let mut label = CodeLabel::default();
-
-        label.push_str(&file_name, None);
-        label.push_str(" ", None);
-
-        if let Some(directory) = directory {
-            label.push_str(&directory, comment_id);
+    fn completion_for_mode(source_range: Range<Anchor>, mode: ContextPickerMode) -> Completion {
+        Completion {
+            replace_range: source_range.clone(),
+            new_text: format!("@{} ", mode.mention_prefix()),
+            label: CodeLabel::plain(mode.label().to_string(), None),
+            icon_path: Some(mode.icon().path().into()),
+            documentation: None,
+            source: project::CompletionSource::Custom,
+            insert_text_mode: None,
+            // This ensures that when a user accepts this completion, the
+            // completion menu will still be shown after "@category " is
+            // inserted
+            confirm: Some(Arc::new(|_, _, _| true)),
         }
-
-        label.filter_range = 0..label.text().len();
-
-        label
     }
 
     fn completion_for_thread(
@@ -159,10 +200,11 @@ impl ContextPickerCompletionProvider {
         let new_text = MentionLink::for_thread(&thread_entry);
         let new_text_len = new_text.len();
         Completion {
-            old_range: source_range.clone(),
+            replace_range: source_range.clone(),
             new_text,
             label: CodeLabel::plain(thread_entry.summary.to_string(), None),
             documentation: None,
+            insert_text_mode: None,
             source: project::CompletionSource::Custom,
             icon_path: Some(icon_for_completion.path().into()),
             confirm: Some(confirm_completion_callback(
@@ -203,12 +245,13 @@ impl ContextPickerCompletionProvider {
         let new_text = MentionLink::for_fetch(&url_to_fetch);
         let new_text_len = new_text.len();
         Completion {
-            old_range: source_range.clone(),
+            replace_range: source_range.clone(),
             new_text,
             label: CodeLabel::plain(url_to_fetch.to_string(), None),
             documentation: None,
             source: project::CompletionSource::Custom,
             icon_path: Some(IconName::Globe.path().into()),
+            insert_text_mode: None,
             confirm: Some(confirm_completion_callback(
                 IconName::Globe.path().into(),
                 url_to_fetch.clone(),
@@ -232,8 +275,8 @@ impl ContextPickerCompletionProvider {
                                 url_to_fetch.to_string(),
                             ))
                             .await?;
-                        context_store.update(cx, |context_store, _| {
-                            context_store.add_fetched_url(url_to_fetch.to_string(), content)
+                        context_store.update(cx, |context_store, cx| {
+                            context_store.add_fetched_url(url_to_fetch.to_string(), content, cx)
                         })
                     })
                     .detach_and_log_err(cx);
@@ -258,11 +301,8 @@ impl ContextPickerCompletionProvider {
             path_prefix,
         );
 
-        let label = Self::build_code_label_for_full_path(
-            &file_name,
-            directory.as_ref().map(|s| s.as_ref()),
-            cx,
-        );
+        let label =
+            build_code_label_for_full_path(&file_name, directory.as_ref().map(|s| s.as_ref()), cx);
         let full_path = if let Some(directory) = directory {
             format!("{}{}", directory, file_name)
         } else {
@@ -284,12 +324,13 @@ impl ContextPickerCompletionProvider {
         let new_text = MentionLink::for_file(&file_name, &full_path);
         let new_text_len = new_text.len();
         Completion {
-            old_range: source_range.clone(),
+            replace_range: source_range.clone(),
             new_text,
             label,
             documentation: None,
             source: project::CompletionSource::Custom,
             icon_path: Some(completion_icon_path),
+            insert_text_mode: None,
             confirm: Some(confirm_completion_callback(
                 crease_icon_path,
                 file_name,
@@ -346,12 +387,13 @@ impl ContextPickerCompletionProvider {
         let new_text = MentionLink::for_symbol(&symbol.name, &full_path);
         let new_text_len = new_text.len();
         Some(Completion {
-            old_range: source_range.clone(),
+            replace_range: source_range.clone(),
             new_text,
             label,
             documentation: None,
             source: project::CompletionSource::Custom,
             icon_path: Some(IconName::Code.path().into()),
+            insert_text_mode: None,
             confirm: Some(confirm_completion_callback(
                 IconName::Code.path().into(),
                 symbol.name.clone().into(),
@@ -377,6 +419,22 @@ impl ContextPickerCompletionProvider {
     }
 }
 
+fn build_code_label_for_full_path(file_name: &str, directory: Option<&str>, cx: &App) -> CodeLabel {
+    let comment_id = cx.theme().syntax().highlight_id("comment").map(HighlightId);
+    let mut label = CodeLabel::default();
+
+    label.push_str(&file_name, None);
+    label.push_str(" ", None);
+
+    if let Some(directory) = directory {
+        label.push_str(&directory, comment_id);
+    }
+
+    label.filter_range = 0..label.text().len();
+
+    label
+}
+
 impl CompletionProvider for ContextPickerCompletionProvider {
     fn completions(
         &self,
@@ -399,10 +457,9 @@ impl CompletionProvider for ContextPickerCompletionProvider {
             return Task::ready(Ok(None));
         };
 
-        let Some(workspace) = self.workspace.upgrade() else {
-            return Task::ready(Ok(None));
-        };
-        let Some(context_store) = self.context_store.upgrade() else {
+        let Some((workspace, context_store)) =
+            self.workspace.upgrade().zip(self.context_store.upgrade())
+        else {
             return Task::ready(Ok(None));
         };
 
@@ -414,154 +471,89 @@ impl CompletionProvider for ContextPickerCompletionProvider {
         let editor = self.editor.clone();
         let http_client = workspace.read(cx).client().http_client().clone();
 
+        let MentionCompletion { mode, argument, .. } = state;
+        let query = argument.unwrap_or_else(|| "".to_string());
+
+        let recent_entries = recent_context_picker_entries(
+            context_store.clone(),
+            thread_store.clone(),
+            workspace.clone(),
+            cx,
+        );
+
+        let search_task = search(
+            mode,
+            query,
+            Arc::<AtomicBool>::default(),
+            recent_entries,
+            thread_store.clone(),
+            workspace.clone(),
+            cx,
+        );
+
         cx.spawn(async move |_, cx| {
-            let mut completions = Vec::new();
+            let matches = search_task.await;
+            let Some(editor) = editor.upgrade() else {
+                return Ok(None);
+            };
 
-            let MentionCompletion { mode, argument, .. } = state;
-
-            let query = argument.unwrap_or_else(|| "".to_string());
-            match mode {
-                Some(ContextPickerMode::File) => {
-                    let path_matches = cx
-                        .update(|cx| {
-                            super::file_context_picker::search_paths(
-                                query,
-                                Arc::<AtomicBool>::default(),
-                                &workspace,
-                                cx,
-                            )
-                        })?
-                        .await;
-
-                    if let Some(editor) = editor.upgrade() {
-                        completions.reserve(path_matches.len());
-                        cx.update(|cx| {
-                            completions.extend(path_matches.iter().map(|mat| {
-                                Self::completion_for_path(
-                                    ProjectPath {
-                                        worktree_id: WorktreeId::from_usize(mat.worktree_id),
-                                        path: mat.path.clone(),
-                                    },
-                                    &mat.path_prefix,
-                                    false,
-                                    mat.is_dir,
-                                    excerpt_id,
-                                    source_range.clone(),
-                                    editor.clone(),
-                                    context_store.clone(),
-                                    cx,
-                                )
-                            }));
-                        })?;
-                    }
-                }
-                Some(ContextPickerMode::Symbol) => {
-                    if let Some(editor) = editor.upgrade() {
-                        let symbol_matches = cx
-                            .update(|cx| {
-                                super::symbol_context_picker::search_symbols(
-                                    query,
-                                    Arc::new(AtomicBool::default()),
-                                    &workspace,
-                                    cx,
-                                )
-                            })?
-                            .await?;
-                        cx.update(|cx| {
-                            completions.extend(symbol_matches.into_iter().filter_map(
-                                |(_, symbol)| {
-                                    Self::completion_for_symbol(
-                                        symbol,
-                                        excerpt_id,
-                                        source_range.clone(),
-                                        editor.clone(),
-                                        context_store.clone(),
-                                        workspace.clone(),
-                                        cx,
-                                    )
+            Ok(Some(cx.update(|cx| {
+                matches
+                    .into_iter()
+                    .filter_map(|mat| match mat {
+                        Match::File(FileMatch { mat, is_recent }) => {
+                            Some(Self::completion_for_path(
+                                ProjectPath {
+                                    worktree_id: WorktreeId::from_usize(mat.worktree_id),
+                                    path: mat.path.clone(),
                                 },
-                            ));
-                        })?;
-                    }
-                }
-                Some(ContextPickerMode::Fetch) => {
-                    if let Some(editor) = editor.upgrade() {
-                        if !query.is_empty() {
-                            completions.push(Self::completion_for_fetch(
-                                source_range.clone(),
-                                query.into(),
+                                &mat.path_prefix,
+                                is_recent,
+                                mat.is_dir,
                                 excerpt_id,
+                                source_range.clone(),
                                 editor.clone(),
                                 context_store.clone(),
-                                http_client.clone(),
-                            ));
-                        }
-
-                        context_store.update(cx, |store, _| {
-                            let urls = store.context().iter().filter_map(|context| {
-                                if let AssistantContext::FetchedUrl(context) = context {
-                                    Some(context.url.clone())
-                                } else {
-                                    None
-                                }
-                            });
-                            for url in urls {
-                                completions.push(Self::completion_for_fetch(
-                                    source_range.clone(),
-                                    url,
-                                    excerpt_id,
-                                    editor.clone(),
-                                    context_store.clone(),
-                                    http_client.clone(),
-                                ));
-                            }
-                        })?;
-                    }
-                }
-                Some(ContextPickerMode::Thread) => {
-                    if let Some((thread_store, editor)) = thread_store
-                        .and_then(|thread_store| thread_store.upgrade())
-                        .zip(editor.upgrade())
-                    {
-                        let threads = cx
-                            .update(|cx| {
-                                super::thread_context_picker::search_threads(
-                                    query,
-                                    thread_store.clone(),
-                                    cx,
-                                )
-                            })?
-                            .await;
-                        for thread in threads {
-                            completions.push(Self::completion_for_thread(
-                                thread.clone(),
-                                excerpt_id,
-                                source_range.clone(),
-                                false,
-                                editor.clone(),
-                                context_store.clone(),
-                                thread_store.clone(),
-                            ));
-                        }
-                    }
-                }
-                None => {
-                    cx.update(|cx| {
-                        if let Some(editor) = editor.upgrade() {
-                            completions.extend(Self::default_completions(
-                                excerpt_id,
-                                source_range.clone(),
-                                context_store.clone(),
-                                thread_store.clone(),
-                                editor,
-                                workspace.clone(),
                                 cx,
-                            ));
+                            ))
                         }
-                    })?;
-                }
-            }
-            Ok(Some(completions))
+                        Match::Symbol(SymbolMatch { symbol, .. }) => Self::completion_for_symbol(
+                            symbol,
+                            excerpt_id,
+                            source_range.clone(),
+                            editor.clone(),
+                            context_store.clone(),
+                            workspace.clone(),
+                            cx,
+                        ),
+                        Match::Thread(ThreadMatch {
+                            thread, is_recent, ..
+                        }) => {
+                            let thread_store = thread_store.as_ref().and_then(|t| t.upgrade())?;
+                            Some(Self::completion_for_thread(
+                                thread,
+                                excerpt_id,
+                                source_range.clone(),
+                                is_recent,
+                                editor.clone(),
+                                context_store.clone(),
+                                thread_store,
+                            ))
+                        }
+                        Match::Fetch(url) => Some(Self::completion_for_fetch(
+                            source_range.clone(),
+                            url,
+                            excerpt_id,
+                            editor.clone(),
+                            context_store.clone(),
+                            http_client.clone(),
+                        )),
+                        Match::Mode(mode) => {
+                            Some(Self::completion_for_mode(source_range.clone(), mode))
+                        }
+                    })
+                    .collect()
+            })?))
         })
     }
 
@@ -618,21 +610,20 @@ fn confirm_completion_callback(
     editor: Entity<Editor>,
     add_context_fn: impl Fn(&mut App) -> () + Send + Sync + 'static,
 ) -> Arc<dyn Fn(CompletionIntent, &mut Window, &mut App) -> bool + Send + Sync> {
-    Arc::new(move |_, window, cx| {
+    Arc::new(move |_, _, cx| {
         add_context_fn(cx);
 
         let crease_text = crease_text.clone();
         let crease_icon_path = crease_icon_path.clone();
         let editor = editor.clone();
-        window.defer(cx, move |window, cx| {
-            crate::context_picker::insert_crease_for_mention(
+        cx.defer(move |cx| {
+            crate::context_picker::insert_fold_for_mention(
                 excerpt_id,
                 start,
                 content_len,
                 crease_text,
                 crease_icon_path,
                 editor,
-                window,
                 cx,
             );
         });
@@ -671,7 +662,12 @@ impl MentionCompletion {
         let mut end = last_mention_start + 1;
         if let Some(mode_text) = parts.next() {
             end += mode_text.len();
-            mode = ContextPickerMode::try_from(mode_text).ok();
+
+            if let Some(parsed_mode) = ContextPickerMode::try_from(mode_text).ok() {
+                mode = Some(parsed_mode);
+            } else {
+                argument = Some(mode_text.to_string());
+            }
             match rest_of_line[mode_text.len()..].find(|c: char| !c.is_whitespace()) {
                 Some(whitespace_count) => {
                     if let Some(argument_text) = parts.next() {
@@ -697,13 +693,14 @@ impl MentionCompletion {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use gpui::{Focusable, TestAppContext, VisualTestContext};
+    use editor::AnchorRangeExt;
+    use gpui::{EventEmitter, FocusHandle, Focusable, TestAppContext, VisualTestContext};
     use project::{Project, ProjectPath};
     use serde_json::json;
     use settings::SettingsStore;
-    use std::{ops::Deref, path::PathBuf};
+    use std::ops::Deref;
     use util::{path, separator};
-    use workspace::AppState;
+    use workspace::{AppState, Item};
 
     #[test]
     fn test_mention_completion_parse() {
@@ -763,9 +760,42 @@ mod tests {
             })
         );
 
+        assert_eq!(
+            MentionCompletion::try_parse("Lorem @main", 0),
+            Some(MentionCompletion {
+                source_range: 6..11,
+                mode: None,
+                argument: Some("main".to_string()),
+            })
+        );
+
         assert_eq!(MentionCompletion::try_parse("test@", 0), None);
     }
 
+    struct AtMentionEditor(Entity<Editor>);
+
+    impl Item for AtMentionEditor {
+        type Event = ();
+
+        fn include_in_nav_history() -> bool {
+            false
+        }
+    }
+
+    impl EventEmitter<()> for AtMentionEditor {}
+
+    impl Focusable for AtMentionEditor {
+        fn focus_handle(&self, cx: &App) -> FocusHandle {
+            self.0.read(cx).focus_handle(cx).clone()
+        }
+    }
+
+    impl Render for AtMentionEditor {
+        fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
+            self.0.clone().into_any_element()
+        }
+    }
+
     #[gpui::test]
     async fn test_context_completion_provider(cx: &mut TestAppContext) {
         init_test(cx);
@@ -841,28 +871,30 @@ mod tests {
                 .unwrap();
         }
 
-        let item = workspace
-            .update_in(&mut cx, |workspace, window, cx| {
-                workspace.open_path(
-                    ProjectPath {
-                        worktree_id,
-                        path: PathBuf::from("editor").into(),
-                    },
+        let editor = workspace.update_in(&mut cx, |workspace, window, cx| {
+            let editor = cx.new(|cx| {
+                Editor::new(
+                    editor::EditorMode::full(),
+                    multi_buffer::MultiBuffer::build_simple("", cx),
                     None,
-                    true,
                     window,
                     cx,
                 )
-            })
-            .await
-            .expect("Could not open test file");
-
-        let editor = cx.update(|_, cx| {
-            item.act_as::<Editor>(cx)
-                .expect("Opened test file wasn't an editor")
+            });
+            workspace.active_pane().update(cx, |pane, cx| {
+                pane.add_item(
+                    Box::new(cx.new(|_| AtMentionEditor(editor.clone()))),
+                    true,
+                    true,
+                    None,
+                    window,
+                    cx,
+                );
+            });
+            editor
         });
 
-        let context_store = cx.new(|_| ContextStore::new(workspace.downgrade(), None));
+        let context_store = cx.new(|_| ContextStore::new(project.downgrade(), None));
 
         let editor_entity = editor.downgrade();
         editor.update_in(&mut cx, |editor, window, cx| {
@@ -932,22 +964,22 @@ mod tests {
         });
 
         editor.update(&mut cx, |editor, cx| {
-            assert_eq!(editor.text(cx), "Lorem [@one.txt](file:dir/a/one.txt)",);
+            assert_eq!(editor.text(cx), "Lorem [@one.txt](@file:dir/a/one.txt)",);
             assert!(!editor.has_visible_completions_menu());
             assert_eq!(
-                crease_ranges(editor, cx),
-                vec![Point::new(0, 6)..Point::new(0, 36)]
+                fold_ranges(editor, cx),
+                vec![Point::new(0, 6)..Point::new(0, 37)]
             );
         });
 
         cx.simulate_input(" ");
 
         editor.update(&mut cx, |editor, cx| {
-            assert_eq!(editor.text(cx), "Lorem [@one.txt](file:dir/a/one.txt) ",);
+            assert_eq!(editor.text(cx), "Lorem [@one.txt](@file:dir/a/one.txt) ",);
             assert!(!editor.has_visible_completions_menu());
             assert_eq!(
-                crease_ranges(editor, cx),
-                vec![Point::new(0, 6)..Point::new(0, 36)]
+                fold_ranges(editor, cx),
+                vec![Point::new(0, 6)..Point::new(0, 37)]
             );
         });
 
@@ -956,12 +988,12 @@ mod tests {
         editor.update(&mut cx, |editor, cx| {
             assert_eq!(
                 editor.text(cx),
-                "Lorem [@one.txt](file:dir/a/one.txt) Ipsum ",
+                "Lorem [@one.txt](@file:dir/a/one.txt) Ipsum ",
             );
             assert!(!editor.has_visible_completions_menu());
             assert_eq!(
-                crease_ranges(editor, cx),
-                vec![Point::new(0, 6)..Point::new(0, 36)]
+                fold_ranges(editor, cx),
+                vec![Point::new(0, 6)..Point::new(0, 37)]
             );
         });
 
@@ -970,12 +1002,12 @@ mod tests {
         editor.update(&mut cx, |editor, cx| {
             assert_eq!(
                 editor.text(cx),
-                "Lorem [@one.txt](file:dir/a/one.txt) Ipsum @file ",
+                "Lorem [@one.txt](@file:dir/a/one.txt) Ipsum @file ",
             );
             assert!(editor.has_visible_completions_menu());
             assert_eq!(
-                crease_ranges(editor, cx),
-                vec![Point::new(0, 6)..Point::new(0, 36)]
+                fold_ranges(editor, cx),
+                vec![Point::new(0, 6)..Point::new(0, 37)]
             );
         });
 
@@ -988,14 +1020,14 @@ mod tests {
         editor.update(&mut cx, |editor, cx| {
             assert_eq!(
                 editor.text(cx),
-                "Lorem [@one.txt](file:dir/a/one.txt) Ipsum [@seven.txt](file:dir/b/seven.txt)"
+                "Lorem [@one.txt](@file:dir/a/one.txt) Ipsum [@seven.txt](@file:dir/b/seven.txt)"
             );
             assert!(!editor.has_visible_completions_menu());
             assert_eq!(
-                crease_ranges(editor, cx),
+                fold_ranges(editor, cx),
                 vec![
-                    Point::new(0, 6)..Point::new(0, 36),
-                    Point::new(0, 43)..Point::new(0, 77)
+                    Point::new(0, 6)..Point::new(0, 37),
+                    Point::new(0, 44)..Point::new(0, 79)
                 ]
             );
         });
@@ -1005,14 +1037,14 @@ mod tests {
         editor.update(&mut cx, |editor, cx| {
             assert_eq!(
                 editor.text(cx),
-                "Lorem [@one.txt](file:dir/a/one.txt) Ipsum [@seven.txt](file:dir/b/seven.txt)\n@"
+                "Lorem [@one.txt](@file:dir/a/one.txt) Ipsum [@seven.txt](@file:dir/b/seven.txt)\n@"
             );
             assert!(editor.has_visible_completions_menu());
             assert_eq!(
-                crease_ranges(editor, cx),
+                fold_ranges(editor, cx),
                 vec![
-                    Point::new(0, 6)..Point::new(0, 36),
-                    Point::new(0, 43)..Point::new(0, 77)
+                    Point::new(0, 6)..Point::new(0, 37),
+                    Point::new(0, 44)..Point::new(0, 79)
                 ]
             );
         });
@@ -1026,29 +1058,27 @@ mod tests {
         editor.update(&mut cx, |editor, cx| {
             assert_eq!(
                 editor.text(cx),
-                "Lorem [@one.txt](file:dir/a/one.txt) Ipsum [@seven.txt](file:dir/b/seven.txt)\n[@six.txt](file:dir/b/six.txt)"
+                "Lorem [@one.txt](@file:dir/a/one.txt) Ipsum [@seven.txt](@file:dir/b/seven.txt)\n[@six.txt](@file:dir/b/six.txt)"
             );
             assert!(!editor.has_visible_completions_menu());
             assert_eq!(
-                crease_ranges(editor, cx),
+                fold_ranges(editor, cx),
                 vec![
-                    Point::new(0, 6)..Point::new(0, 36),
-                    Point::new(0, 43)..Point::new(0, 77),
-                    Point::new(1, 0)..Point::new(1, 30)
+                    Point::new(0, 6)..Point::new(0, 37),
+                    Point::new(0, 44)..Point::new(0, 79),
+                    Point::new(1, 0)..Point::new(1, 31)
                 ]
             );
         });
     }
 
-    fn crease_ranges(editor: &Editor, cx: &mut App) -> Vec<Range<Point>> {
+    fn fold_ranges(editor: &Editor, cx: &mut App) -> Vec<Range<Point>> {
         let snapshot = editor.buffer().read(cx).snapshot(cx);
         editor.display_map.update(cx, |display_map, cx| {
             display_map
                 .snapshot(cx)
-                .crease_snapshot
-                .crease_items_with_offsets(&snapshot)
-                .into_iter()
-                .map(|(_, range)| range)
+                .folds_in_range(0..snapshot.len())
+                .map(|fold| fold.range.to_point(&snapshot))
                 .collect()
         })
     }

crates/agent/src/context_picker/fetch_context_picker.rs

@@ -11,7 +11,7 @@ use picker::{Picker, PickerDelegate};
 use ui::{Context, ListItem, Window, prelude::*};
 use workspace::Workspace;
 
-use crate::context_picker::{ConfirmBehavior, ContextPicker};
+use crate::context_picker::ContextPicker;
 use crate::context_store::ContextStore;
 
 pub struct FetchContextPicker {
@@ -23,16 +23,10 @@ impl FetchContextPicker {
         context_picker: WeakEntity<ContextPicker>,
         workspace: WeakEntity<Workspace>,
         context_store: WeakEntity<ContextStore>,
-        confirm_behavior: ConfirmBehavior,
         window: &mut Window,
         cx: &mut Context<Self>,
     ) -> Self {
-        let delegate = FetchContextPickerDelegate::new(
-            context_picker,
-            workspace,
-            context_store,
-            confirm_behavior,
-        );
+        let delegate = FetchContextPickerDelegate::new(context_picker, workspace, context_store);
         let picker = cx.new(|cx| Picker::uniform_list(delegate, window, cx));
 
         Self { picker }
@@ -62,7 +56,6 @@ pub struct FetchContextPickerDelegate {
     context_picker: WeakEntity<ContextPicker>,
     workspace: WeakEntity<Workspace>,
     context_store: WeakEntity<ContextStore>,
-    confirm_behavior: ConfirmBehavior,
     url: String,
 }
 
@@ -71,13 +64,11 @@ impl FetchContextPickerDelegate {
         context_picker: WeakEntity<ContextPicker>,
         workspace: WeakEntity<Workspace>,
         context_store: WeakEntity<ContextStore>,
-        confirm_behavior: ConfirmBehavior,
     ) -> Self {
         FetchContextPickerDelegate {
             context_picker,
             workspace,
             context_store,
-            confirm_behavior,
             url: String::new(),
         }
     }
@@ -204,25 +195,15 @@ impl PickerDelegate for FetchContextPickerDelegate {
 
         let http_client = workspace.read(cx).client().http_client().clone();
         let url = self.url.clone();
-        let confirm_behavior = self.confirm_behavior;
         cx.spawn_in(window, async move |this, cx| {
             let text = cx
                 .background_spawn(fetch_url_content(http_client, url.clone()))
                 .await?;
 
-            this.update_in(cx, |this, window, cx| {
-                this.delegate
-                    .context_store
-                    .update(cx, |context_store, _cx| {
-                        context_store.add_fetched_url(url, text);
-                    })?;
-
-                match confirm_behavior {
-                    ConfirmBehavior::KeepOpen => {}
-                    ConfirmBehavior::Close => this.delegate.dismissed(window, cx),
-                }
-
-                anyhow::Ok(())
+            this.update(cx, |this, cx| {
+                this.delegate.context_store.update(cx, |context_store, cx| {
+                    context_store.add_fetched_url(url, text, cx)
+                })
             })??;
 
             anyhow::Ok(())

crates/agent/src/context_picker/file_context_picker.rs

@@ -11,9 +11,9 @@ use picker::{Picker, PickerDelegate};
 use project::{PathMatchCandidateSet, ProjectPath, WorktreeId};
 use ui::{ListItem, Tooltip, prelude::*};
 use util::ResultExt as _;
-use workspace::{Workspace, notifications::NotifyResultExt};
+use workspace::Workspace;
 
-use crate::context_picker::{ConfirmBehavior, ContextPicker};
+use crate::context_picker::ContextPicker;
 use crate::context_store::{ContextStore, FileInclusion};
 
 pub struct FileContextPicker {
@@ -25,16 +25,10 @@ impl FileContextPicker {
         context_picker: WeakEntity<ContextPicker>,
         workspace: WeakEntity<Workspace>,
         context_store: WeakEntity<ContextStore>,
-        confirm_behavior: ConfirmBehavior,
         window: &mut Window,
         cx: &mut Context<Self>,
     ) -> Self {
-        let delegate = FileContextPickerDelegate::new(
-            context_picker,
-            workspace,
-            context_store,
-            confirm_behavior,
-        );
+        let delegate = FileContextPickerDelegate::new(context_picker, workspace, context_store);
         let picker = cx.new(|cx| Picker::uniform_list(delegate, window, cx));
 
         Self { picker }
@@ -57,8 +51,7 @@ pub struct FileContextPickerDelegate {
     context_picker: WeakEntity<ContextPicker>,
     workspace: WeakEntity<Workspace>,
     context_store: WeakEntity<ContextStore>,
-    confirm_behavior: ConfirmBehavior,
-    matches: Vec<PathMatch>,
+    matches: Vec<FileMatch>,
     selected_index: usize,
 }
 
@@ -67,13 +60,11 @@ impl FileContextPickerDelegate {
         context_picker: WeakEntity<ContextPicker>,
         workspace: WeakEntity<Workspace>,
         context_store: WeakEntity<ContextStore>,
-        confirm_behavior: ConfirmBehavior,
     ) -> Self {
         Self {
             context_picker,
             workspace,
             context_store,
-            confirm_behavior,
             matches: Vec::new(),
             selected_index: 0,
         }
@@ -114,7 +105,7 @@ impl PickerDelegate for FileContextPickerDelegate {
             return Task::ready(());
         };
 
-        let search_task = search_paths(query, Arc::<AtomicBool>::default(), &workspace, cx);
+        let search_task = search_files(query, Arc::<AtomicBool>::default(), &workspace, cx);
 
         cx.spawn_in(window, async move |this, cx| {
             // TODO: This should be probably be run in the background.
@@ -127,8 +118,8 @@ impl PickerDelegate for FileContextPickerDelegate {
         })
     }
 
-    fn confirm(&mut self, _secondary: bool, window: &mut Window, cx: &mut Context<Picker<Self>>) {
-        let Some(mat) = self.matches.get(self.selected_index) else {
+    fn confirm(&mut self, _secondary: bool, _window: &mut Window, cx: &mut Context<Picker<Self>>) {
+        let Some(FileMatch { mat, .. }) = self.matches.get(self.selected_index) else {
             return;
         };
 
@@ -153,17 +144,7 @@ impl PickerDelegate for FileContextPickerDelegate {
             return;
         };
 
-        let confirm_behavior = self.confirm_behavior;
-        cx.spawn_in(window, async move |this, cx| {
-            match task.await.notify_async_err(cx) {
-                None => anyhow::Ok(()),
-                Some(()) => this.update_in(cx, |this, window, cx| match confirm_behavior {
-                    ConfirmBehavior::KeepOpen => {}
-                    ConfirmBehavior::Close => this.delegate.dismissed(window, cx),
-                }),
-            }
-        })
-        .detach_and_log_err(cx);
+        task.detach_and_log_err(cx);
     }
 
     fn dismissed(&mut self, _: &mut Window, cx: &mut Context<Picker<Self>>) {
@@ -181,7 +162,7 @@ impl PickerDelegate for FileContextPickerDelegate {
         _window: &mut Window,
         cx: &mut Context<Picker<Self>>,
     ) -> Option<Self::ListItem> {
-        let path_match = &self.matches[ix];
+        let FileMatch { mat, .. } = &self.matches[ix];
 
         Some(
             ListItem::new(ix)
@@ -189,9 +170,10 @@ impl PickerDelegate for FileContextPickerDelegate {
                 .toggle_state(selected)
                 .child(render_file_context_entry(
                     ElementId::NamedInteger("file-ctx-picker".into(), ix),
-                    &path_match.path,
-                    &path_match.path_prefix,
-                    path_match.is_dir,
+                    WorktreeId::from_usize(mat.worktree_id),
+                    &mat.path,
+                    &mat.path_prefix,
+                    mat.is_dir,
                     self.context_store.clone(),
                     cx,
                 )),
@@ -199,12 +181,17 @@ impl PickerDelegate for FileContextPickerDelegate {
     }
 }
 
-pub(crate) fn search_paths(
+pub struct FileMatch {
+    pub mat: PathMatch,
+    pub is_recent: bool,
+}
+
+pub(crate) fn search_files(
     query: String,
     cancellation_flag: Arc<AtomicBool>,
     workspace: &Entity<Workspace>,
     cx: &App,
-) -> Task<Vec<PathMatch>> {
+) -> Task<Vec<FileMatch>> {
     if query.is_empty() {
         let workspace = workspace.read(cx);
         let project = workspace.project().read(cx);
@@ -213,28 +200,34 @@ pub(crate) fn search_paths(
             .into_iter()
             .filter_map(|(project_path, _)| {
                 let worktree = project.worktree_for_id(project_path.worktree_id, cx)?;
-                Some(PathMatch {
-                    score: 0.,
-                    positions: Vec::new(),
-                    worktree_id: project_path.worktree_id.to_usize(),
-                    path: project_path.path,
-                    path_prefix: worktree.read(cx).root_name().into(),
-                    distance_to_relative_ancestor: 0,
-                    is_dir: false,
+                Some(FileMatch {
+                    mat: PathMatch {
+                        score: 0.,
+                        positions: Vec::new(),
+                        worktree_id: project_path.worktree_id.to_usize(),
+                        path: project_path.path,
+                        path_prefix: worktree.read(cx).root_name().into(),
+                        distance_to_relative_ancestor: 0,
+                        is_dir: false,
+                    },
+                    is_recent: true,
                 })
             });
 
         let file_matches = project.worktrees(cx).flat_map(|worktree| {
             let worktree = worktree.read(cx);
             let path_prefix: Arc<str> = worktree.root_name().into();
-            worktree.entries(false, 0).map(move |entry| PathMatch {
-                score: 0.,
-                positions: Vec::new(),
-                worktree_id: worktree.id().to_usize(),
-                path: entry.path.clone(),
-                path_prefix: path_prefix.clone(),
-                distance_to_relative_ancestor: 0,
-                is_dir: entry.is_dir(),
+            worktree.entries(false, 0).map(move |entry| FileMatch {
+                mat: PathMatch {
+                    score: 0.,
+                    positions: Vec::new(),
+                    worktree_id: worktree.id().to_usize(),
+                    path: entry.path.clone(),
+                    path_prefix: path_prefix.clone(),
+                    distance_to_relative_ancestor: 0,
+                    is_dir: entry.is_dir(),
+                },
+                is_recent: false,
             })
         });
 
@@ -269,6 +262,12 @@ pub(crate) fn search_paths(
                 executor,
             )
             .await
+            .into_iter()
+            .map(|mat| FileMatch {
+                mat,
+                is_recent: false,
+            })
+            .collect::<Vec<_>>()
         })
     }
 }
@@ -311,19 +310,26 @@ pub fn extract_file_name_and_directory(
 
 pub fn render_file_context_entry(
     id: ElementId,
-    path: &Path,
+    worktree_id: WorktreeId,
+    path: &Arc<Path>,
     path_prefix: &Arc<str>,
     is_directory: bool,
     context_store: WeakEntity<ContextStore>,
     cx: &App,
 ) -> Stateful<Div> {
-    let (file_name, directory) = extract_file_name_and_directory(path, path_prefix);
+    let (file_name, directory) = extract_file_name_and_directory(&path, path_prefix);
 
     let added = context_store.upgrade().and_then(|context_store| {
+        let project_path = ProjectPath {
+            worktree_id,
+            path: path.clone(),
+        };
         if is_directory {
-            context_store.read(cx).includes_directory(path)
+            context_store.read(cx).includes_directory(&project_path)
         } else {
-            context_store.read(cx).will_include_file_path(path, cx)
+            context_store
+                .read(cx)
+                .will_include_file_path(&project_path, cx)
         }
     });
 
@@ -363,8 +369,9 @@ pub fn render_file_context_entry(
                     )
                     .child(Label::new("Added").size(LabelSize::Small)),
             ),
-            FileInclusion::InDirectory(dir_name) => {
-                let dir_name = dir_name.to_string_lossy().into_owned();
+            FileInclusion::InDirectory(directory_project_path) => {
+                // TODO: Consider using worktree full_path to include worktree name.
+                let directory_path = directory_project_path.path.to_string_lossy().into_owned();
 
                 el.child(
                     h_flex()
@@ -378,7 +385,7 @@ pub fn render_file_context_entry(
                         )
                         .child(Label::new("Included").size(LabelSize::Small)),
                 )
-                .tooltip(Tooltip::text(format!("in {dir_name}")))
+                .tooltip(Tooltip::text(format!("in {directory_path}")))
             }
         })
 }

crates/agent/src/context_picker/symbol_context_picker.rs

@@ -2,7 +2,7 @@ use std::cmp::Reverse;
 use std::sync::Arc;
 use std::sync::atomic::AtomicBool;
 
-use anyhow::{Context as _, Result};
+use anyhow::Result;
 use fuzzy::{StringMatch, StringMatchCandidate};
 use gpui::{
     App, AppContext, DismissEvent, Entity, FocusHandle, Focusable, Stateful, Task, WeakEntity,
@@ -15,7 +15,7 @@ use ui::{ListItem, prelude::*};
 use util::ResultExt as _;
 use workspace::Workspace;
 
-use crate::context_picker::{ConfirmBehavior, ContextPicker};
+use crate::context_picker::ContextPicker;
 use crate::context_store::ContextStore;
 
 pub struct SymbolContextPicker {
@@ -27,16 +27,10 @@ impl SymbolContextPicker {
         context_picker: WeakEntity<ContextPicker>,
         workspace: WeakEntity<Workspace>,
         context_store: WeakEntity<ContextStore>,
-        confirm_behavior: ConfirmBehavior,
         window: &mut Window,
         cx: &mut Context<Self>,
     ) -> Self {
-        let delegate = SymbolContextPickerDelegate::new(
-            context_picker,
-            workspace,
-            context_store,
-            confirm_behavior,
-        );
+        let delegate = SymbolContextPickerDelegate::new(context_picker, workspace, context_store);
         let picker = cx.new(|cx| Picker::uniform_list(delegate, window, cx));
 
         Self { picker }
@@ -59,7 +53,6 @@ pub struct SymbolContextPickerDelegate {
     context_picker: WeakEntity<ContextPicker>,
     workspace: WeakEntity<Workspace>,
     context_store: WeakEntity<ContextStore>,
-    confirm_behavior: ConfirmBehavior,
     matches: Vec<SymbolEntry>,
     selected_index: usize,
 }
@@ -69,13 +62,11 @@ impl SymbolContextPickerDelegate {
         context_picker: WeakEntity<ContextPicker>,
         workspace: WeakEntity<Workspace>,
         context_store: WeakEntity<ContextStore>,
-        confirm_behavior: ConfirmBehavior,
     ) -> Self {
         Self {
             context_picker,
             workspace,
             context_store,
-            confirm_behavior,
             matches: Vec::new(),
             selected_index: 0,
         }
@@ -119,11 +110,7 @@ impl PickerDelegate for SymbolContextPickerDelegate {
         let search_task = search_symbols(query, Arc::<AtomicBool>::default(), &workspace, cx);
         let context_store = self.context_store.clone();
         cx.spawn_in(window, async move |this, cx| {
-            let symbols = search_task
-                .await
-                .context("Failed to load symbols")
-                .log_err()
-                .unwrap_or_default();
+            let symbols = search_task.await;
 
             let symbol_entries = context_store
                 .read_with(cx, |context_store, cx| {
@@ -139,7 +126,7 @@ impl PickerDelegate for SymbolContextPickerDelegate {
         })
     }
 
-    fn confirm(&mut self, _secondary: bool, window: &mut Window, cx: &mut Context<Picker<Self>>) {
+    fn confirm(&mut self, _secondary: bool, _window: &mut Window, cx: &mut Context<Picker<Self>>) {
         let Some(mat) = self.matches.get(self.selected_index) else {
             return;
         };
@@ -147,7 +134,6 @@ impl PickerDelegate for SymbolContextPickerDelegate {
             return;
         };
 
-        let confirm_behavior = self.confirm_behavior;
         let add_symbol_task = add_symbol(
             mat.symbol.clone(),
             true,
@@ -157,16 +143,12 @@ impl PickerDelegate for SymbolContextPickerDelegate {
         );
 
         let selected_index = self.selected_index;
-        cx.spawn_in(window, async move |this, cx| {
+        cx.spawn(async move |this, cx| {
             let included = add_symbol_task.await?;
-            this.update_in(cx, |this, window, cx| {
+            this.update(cx, |this, _| {
                 if let Some(mat) = this.delegate.matches.get_mut(selected_index) {
                     mat.is_included = included;
                 }
-                match confirm_behavior {
-                    ConfirmBehavior::KeepOpen => {}
-                    ConfirmBehavior::Close => this.delegate.dismissed(window, cx),
-                }
             })
         })
         .detach_and_log_err(cx);
@@ -285,12 +267,16 @@ fn find_matching_symbol(symbol: &Symbol, candidates: &[DocumentSymbol]) -> Optio
     }
 }
 
+pub struct SymbolMatch {
+    pub symbol: Symbol,
+}
+
 pub(crate) fn search_symbols(
     query: String,
     cancellation_flag: Arc<AtomicBool>,
     workspace: &Entity<Workspace>,
     cx: &mut App,
-) -> Task<Result<Vec<(StringMatch, Symbol)>>> {
+) -> Task<Vec<SymbolMatch>> {
     let symbols_task = workspace.update(cx, |workspace, cx| {
         workspace
             .project()
@@ -298,19 +284,28 @@ pub(crate) fn search_symbols(
     });
     let project = workspace.read(cx).project().clone();
     cx.spawn(async move |cx| {
-        let symbols = symbols_task.await?;
-        let (visible_match_candidates, external_match_candidates): (Vec<_>, Vec<_>) = project
-            .update(cx, |project, cx| {
-                symbols
-                    .iter()
-                    .enumerate()
-                    .map(|(id, symbol)| StringMatchCandidate::new(id, &symbol.label.filter_text()))
-                    .partition(|candidate| {
-                        project
-                            .entry_for_path(&symbols[candidate.id].path, cx)
-                            .map_or(false, |e| !e.is_ignored)
-                    })
-            })?;
+        let Some(symbols) = symbols_task.await.log_err() else {
+            return Vec::new();
+        };
+        let Some((visible_match_candidates, external_match_candidates)): Option<(Vec<_>, Vec<_>)> =
+            project
+                .update(cx, |project, cx| {
+                    symbols
+                        .iter()
+                        .enumerate()
+                        .map(|(id, symbol)| {
+                            StringMatchCandidate::new(id, &symbol.label.filter_text())
+                        })
+                        .partition(|candidate| {
+                            project
+                                .entry_for_path(&symbols[candidate.id].path, cx)
+                                .map_or(false, |e| !e.is_ignored)
+                        })
+                })
+                .log_err()
+        else {
+            return Vec::new();
+        };
 
         const MAX_MATCHES: usize = 100;
         let mut visible_matches = cx.background_executor().block(fuzzy::match_strings(
@@ -339,7 +334,7 @@ pub(crate) fn search_symbols(
         let mut matches = visible_matches;
         matches.append(&mut external_matches);
 
-        Ok(matches
+        matches
             .into_iter()
             .map(|mut mat| {
                 let symbol = symbols[mat.candidate_id].clone();
@@ -347,19 +342,19 @@ pub(crate) fn search_symbols(
                 for position in &mut mat.positions {
                     *position += filter_start;
                 }
-                (mat, symbol)
+                SymbolMatch { symbol }
             })
-            .collect())
+            .collect()
     })
 }
 
 fn compute_symbol_entries(
-    symbols: Vec<(StringMatch, Symbol)>,
+    symbols: Vec<SymbolMatch>,
     context_store: &ContextStore,
     cx: &App,
 ) -> Vec<SymbolEntry> {
     let mut symbol_entries = Vec::with_capacity(symbols.len());
-    for (_, symbol) in symbols {
+    for SymbolMatch { symbol, .. } in symbols {
         let symbols_for_path = context_store.included_symbols_by_path().get(&symbol.path);
         let is_included = if let Some(symbols_for_path) = symbols_for_path {
             let mut is_included = false;

crates/agent/src/context_picker/thread_context_picker.rs

@@ -1,11 +1,12 @@
 use std::sync::Arc;
+use std::sync::atomic::AtomicBool;
 
 use fuzzy::StringMatchCandidate;
 use gpui::{App, DismissEvent, Entity, FocusHandle, Focusable, Task, WeakEntity};
 use picker::{Picker, PickerDelegate};
 use ui::{ListItem, prelude::*};
 
-use crate::context_picker::{ConfirmBehavior, ContextPicker};
+use crate::context_picker::ContextPicker;
 use crate::context_store::{self, ContextStore};
 use crate::thread::ThreadId;
 use crate::thread_store::ThreadStore;
@@ -19,16 +20,11 @@ impl ThreadContextPicker {
         thread_store: WeakEntity<ThreadStore>,
         context_picker: WeakEntity<ContextPicker>,
         context_store: WeakEntity<context_store::ContextStore>,
-        confirm_behavior: ConfirmBehavior,
         window: &mut Window,
         cx: &mut Context<Self>,
     ) -> Self {
-        let delegate = ThreadContextPickerDelegate::new(
-            thread_store,
-            context_picker,
-            context_store,
-            confirm_behavior,
-        );
+        let delegate =
+            ThreadContextPickerDelegate::new(thread_store, context_picker, context_store);
         let picker = cx.new(|cx| Picker::uniform_list(delegate, window, cx));
 
         ThreadContextPicker { picker }
@@ -57,7 +53,6 @@ pub struct ThreadContextPickerDelegate {
     thread_store: WeakEntity<ThreadStore>,
     context_picker: WeakEntity<ContextPicker>,
     context_store: WeakEntity<context_store::ContextStore>,
-    confirm_behavior: ConfirmBehavior,
     matches: Vec<ThreadContextEntry>,
     selected_index: usize,
 }
@@ -67,13 +62,11 @@ impl ThreadContextPickerDelegate {
         thread_store: WeakEntity<ThreadStore>,
         context_picker: WeakEntity<ContextPicker>,
         context_store: WeakEntity<context_store::ContextStore>,
-        confirm_behavior: ConfirmBehavior,
     ) -> Self {
         ThreadContextPickerDelegate {
             thread_store,
             context_picker,
             context_store,
-            confirm_behavior,
             matches: Vec::new(),
             selected_index: 0,
         }
@@ -114,11 +107,11 @@ impl PickerDelegate for ThreadContextPickerDelegate {
             return Task::ready(());
         };
 
-        let search_task = search_threads(query, threads, cx);
+        let search_task = search_threads(query, Arc::new(AtomicBool::default()), threads, cx);
         cx.spawn_in(window, async move |this, cx| {
             let matches = search_task.await;
             this.update(cx, |this, cx| {
-                this.delegate.matches = matches;
+                this.delegate.matches = matches.into_iter().map(|mat| mat.thread).collect();
                 this.delegate.selected_index = 0;
                 cx.notify();
             })
@@ -126,7 +119,7 @@ impl PickerDelegate for ThreadContextPickerDelegate {
         })
     }
 
-    fn confirm(&mut self, _secondary: bool, window: &mut Window, cx: &mut Context<Picker<Self>>) {
+    fn confirm(&mut self, _secondary: bool, _window: &mut Window, cx: &mut Context<Picker<Self>>) {
         let Some(entry) = self.matches.get(self.selected_index) else {
             return;
         };
@@ -137,20 +130,15 @@ impl PickerDelegate for ThreadContextPickerDelegate {
 
         let open_thread_task = thread_store.update(cx, |this, cx| this.open_thread(&entry.id, cx));
 
-        cx.spawn_in(window, async move |this, cx| {
+        cx.spawn(async move |this, cx| {
             let thread = open_thread_task.await?;
-            this.update_in(cx, |this, window, cx| {
+            this.update(cx, |this, cx| {
                 this.delegate
                     .context_store
                     .update(cx, |context_store, cx| {
                         context_store.add_thread(thread, true, cx)
                     })
                     .ok();
-
-                match this.delegate.confirm_behavior {
-                    ConfirmBehavior::KeepOpen => {}
-                    ConfirmBehavior::Close => this.delegate.dismissed(window, cx),
-                }
             })
         })
         .detach_and_log_err(cx);
@@ -217,11 +205,18 @@ pub fn render_thread_context_entry(
         })
 }
 
+#[derive(Clone)]
+pub struct ThreadMatch {
+    pub thread: ThreadContextEntry,
+    pub is_recent: bool,
+}
+
 pub(crate) fn search_threads(
     query: String,
+    cancellation_flag: Arc<AtomicBool>,
     thread_store: Entity<ThreadStore>,
     cx: &mut App,
-) -> Task<Vec<ThreadContextEntry>> {
+) -> Task<Vec<ThreadMatch>> {
     let threads = thread_store.update(cx, |this, _cx| {
         this.threads()
             .into_iter()
@@ -236,6 +231,12 @@ pub(crate) fn search_threads(
     cx.background_spawn(async move {
         if query.is_empty() {
             threads
+                .into_iter()
+                .map(|thread| ThreadMatch {
+                    thread,
+                    is_recent: false,
+                })
+                .collect()
         } else {
             let candidates = threads
                 .iter()
@@ -247,14 +248,17 @@ pub(crate) fn search_threads(
                 &query,
                 false,
                 100,
-                &Default::default(),
+                &cancellation_flag,
                 executor,
             )
             .await;
 
             matches
                 .into_iter()
-                .map(|mat| threads[mat.candidate_id].clone())
+                .map(|mat| ThreadMatch {
+                    thread: threads[mat.candidate_id].clone(),
+                    is_recent: false,
+                })
                 .collect()
         }
     })

crates/agent/src/context_store.rs

@@ -1,18 +1,17 @@
 use std::ops::Range;
-use std::path::{Path, PathBuf};
+use std::path::Path;
 use std::sync::Arc;
 
 use anyhow::{Context as _, Result, anyhow};
 use collections::{BTreeMap, HashMap, HashSet};
 use futures::future::join_all;
 use futures::{self, Future, FutureExt, future};
-use gpui::{App, AppContext as _, AsyncApp, Context, Entity, SharedString, Task, WeakEntity};
+use gpui::{App, AppContext as _, Context, Entity, SharedString, Task, WeakEntity};
 use language::{Buffer, File};
-use project::{ProjectItem, ProjectPath, Worktree};
+use project::{Project, ProjectItem, ProjectPath, Worktree};
 use rope::Rope;
 use text::{Anchor, BufferId, OffsetRangeExt};
 use util::{ResultExt as _, maybe};
-use workspace::Workspace;
 
 use crate::ThreadStore;
 use crate::context::{
@@ -23,13 +22,13 @@ use crate::context_strip::SuggestedContext;
 use crate::thread::{Thread, ThreadId};
 
 pub struct ContextStore {
-    workspace: WeakEntity<Workspace>,
+    project: WeakEntity<Project>,
     context: Vec<AssistantContext>,
     thread_store: Option<WeakEntity<ThreadStore>>,
     // TODO: If an EntityId is used for all context types (like BufferId), can remove ContextId.
     next_context_id: ContextId,
     files: BTreeMap<BufferId, ContextId>,
-    directories: HashMap<PathBuf, ContextId>,
+    directories: HashMap<ProjectPath, ContextId>,
     symbols: HashMap<ContextSymbolId, ContextId>,
     symbol_buffers: HashMap<ContextSymbolId, Entity<Buffer>>,
     symbols_by_path: HashMap<ProjectPath, Vec<ContextSymbolId>>,
@@ -40,11 +39,11 @@ pub struct ContextStore {
 
 impl ContextStore {
     pub fn new(
-        workspace: WeakEntity<Workspace>,
+        project: WeakEntity<Project>,
         thread_store: Option<WeakEntity<ThreadStore>>,
     ) -> Self {
         Self {
-            workspace,
+            project,
             thread_store,
             context: Vec::new(),
             next_context_id: ContextId(0),
@@ -81,12 +80,7 @@ impl ContextStore {
         remove_if_exists: bool,
         cx: &mut Context<Self>,
     ) -> Task<Result<()>> {
-        let workspace = self.workspace.clone();
-
-        let Some(project) = workspace
-            .upgrade()
-            .map(|workspace| workspace.read(cx).project().clone())
-        else {
+        let Some(project) = self.project.upgrade() else {
             return Task::ready(Err(anyhow!("failed to read project")));
         };
 
@@ -95,14 +89,14 @@ impl ContextStore {
                 project.open_buffer(project_path.clone(), cx)
             })?;
 
-            let buffer_entity = open_buffer_task.await?;
-            let buffer_id = this.update(cx, |_, cx| buffer_entity.read(cx).remote_id())?;
+            let buffer = open_buffer_task.await?;
+            let buffer_id = this.update(cx, |_, cx| buffer.read(cx).remote_id())?;
 
-            let already_included = this.update(cx, |this, _cx| {
-                match this.will_include_buffer(buffer_id, &project_path.path) {
+            let already_included = this.update(cx, |this, cx| {
+                match this.will_include_buffer(buffer_id, &project_path) {
                     Some(FileInclusion::Direct(context_id)) => {
                         if remove_if_exists {
-                            this.remove_context(context_id);
+                            this.remove_context(context_id, cx);
                         }
                         true
                     }
@@ -115,21 +109,13 @@ impl ContextStore {
                 return anyhow::Ok(());
             }
 
-            let (buffer_info, text_task) = this.update(cx, |_, cx| {
-                let buffer = buffer_entity.read(cx);
-                collect_buffer_info_and_text(
-                    project_path.path.clone(),
-                    buffer_entity,
-                    buffer,
-                    None,
-                    cx.to_async(),
-                )
-            })??;
+            let (buffer_info, text_task) =
+                this.update(cx, |_, cx| collect_buffer_info_and_text(buffer, None, cx))??;
 
             let text = text_task.await;
 
-            this.update(cx, |this, _cx| {
-                this.insert_file(make_context_buffer(buffer_info, text));
+            this.update(cx, |this, cx| {
+                this.insert_file(make_context_buffer(buffer_info, text), cx);
             })?;
 
             anyhow::Ok(())
@@ -138,41 +124,29 @@ impl ContextStore {
 
     pub fn add_file_from_buffer(
         &mut self,
-        buffer_entity: Entity<Buffer>,
+        buffer: Entity<Buffer>,
         cx: &mut Context<Self>,
     ) -> Task<Result<()>> {
         cx.spawn(async move |this, cx| {
-            let (buffer_info, text_task) = this.update(cx, |_, cx| {
-                let buffer = buffer_entity.read(cx);
-                let Some(file) = buffer.file() else {
-                    return Err(anyhow!("Buffer has no path."));
-                };
-                collect_buffer_info_and_text(
-                    file.path().clone(),
-                    buffer_entity,
-                    buffer,
-                    None,
-                    cx.to_async(),
-                )
-            })??;
+            let (buffer_info, text_task) =
+                this.update(cx, |_, cx| collect_buffer_info_and_text(buffer, None, cx))??;
 
             let text = text_task.await;
 
-            this.update(cx, |this, _cx| {
-                this.insert_file(make_context_buffer(buffer_info, text))
+            this.update(cx, |this, cx| {
+                this.insert_file(make_context_buffer(buffer_info, text), cx)
             })?;
 
             anyhow::Ok(())
         })
     }
 
-    fn insert_file(&mut self, context_buffer: ContextBuffer) {
+    fn insert_file(&mut self, context_buffer: ContextBuffer, cx: &mut Context<Self>) {
         let id = self.next_context_id.post_inc();
         self.files.insert(context_buffer.id, id);
-        self.context.push(AssistantContext::File(FileContext {
-            id,
-            context_buffer: context_buffer,
-        }));
+        self.context
+            .push(AssistantContext::File(FileContext { id, context_buffer }));
+        cx.notify();
     }
 
     pub fn add_directory(
@@ -181,18 +155,14 @@ impl ContextStore {
         remove_if_exists: bool,
         cx: &mut Context<Self>,
     ) -> Task<Result<()>> {
-        let workspace = self.workspace.clone();
-        let Some(project) = workspace
-            .upgrade()
-            .map(|workspace| workspace.read(cx).project().clone())
-        else {
+        let Some(project) = self.project.upgrade() else {
             return Task::ready(Err(anyhow!("failed to read project")));
         };
 
-        let already_included = match self.includes_directory(&project_path.path) {
+        let already_included = match self.includes_directory(&project_path) {
             Some(FileInclusion::Direct(context_id)) => {
                 if remove_if_exists {
-                    self.remove_context(context_id);
+                    self.remove_context(context_id, cx);
                 }
                 true
             }
@@ -233,22 +203,13 @@ impl ContextStore {
             let mut buffer_infos = Vec::new();
             let mut text_tasks = Vec::new();
             this.update(cx, |_, cx| {
-                for (path, buffer_entity) in files.into_iter().zip(buffers) {
-                    // Skip all binary files and other non-UTF8 files
-                    if let Ok(buffer_entity) = buffer_entity {
-                        let buffer = buffer_entity.read(cx);
-                        if let Some((buffer_info, text_task)) = collect_buffer_info_and_text(
-                            path,
-                            buffer_entity,
-                            buffer,
-                            None,
-                            cx.to_async(),
-                        )
-                        .log_err()
-                        {
-                            buffer_infos.push(buffer_info);
-                            text_tasks.push(text_task);
-                        }
+                // Skip all binary files and other non-UTF8 files
+                for buffer in buffers.into_iter().flatten() {
+                    if let Some((buffer_info, text_task)) =
+                        collect_buffer_info_and_text(buffer, None, cx).log_err()
+                    {
+                        buffer_infos.push(buffer_info);
+                        text_tasks.push(text_task);
                     }
                 }
                 anyhow::Ok(())
@@ -262,30 +223,37 @@ impl ContextStore {
                 .collect::<Vec<_>>();
 
             if context_buffers.is_empty() {
-                return Err(anyhow!(
-                    "No text files found in {}",
-                    &project_path.path.display()
-                ));
+                let full_path = cx.update(|cx| worktree.read(cx).full_path(&project_path.path))?;
+                return Err(anyhow!("No text files found in {}", &full_path.display()));
             }
 
-            this.update(cx, |this, _| {
-                this.insert_directory(project_path, context_buffers);
+            this.update(cx, |this, cx| {
+                this.insert_directory(worktree, project_path, context_buffers, cx);
             })?;
 
             anyhow::Ok(())
         })
     }
 
-    fn insert_directory(&mut self, project_path: ProjectPath, context_buffers: Vec<ContextBuffer>) {
+    fn insert_directory(
+        &mut self,
+        worktree: Entity<Worktree>,
+        project_path: ProjectPath,
+        context_buffers: Vec<ContextBuffer>,
+        cx: &mut Context<Self>,
+    ) {
         let id = self.next_context_id.post_inc();
-        self.directories.insert(project_path.path.to_path_buf(), id);
+        let path = project_path.path.clone();
+        self.directories.insert(project_path, id);
 
         self.context
             .push(AssistantContext::Directory(DirectoryContext {
                 id,
-                project_path,
+                worktree,
+                path,
                 context_buffers,
             }));
+        cx.notify();
     }
 
     pub fn add_symbol(
@@ -298,12 +266,8 @@ impl ContextStore {
         cx: &mut Context<Self>,
     ) -> Task<Result<bool>> {
         let buffer_ref = buffer.read(cx);
-        let Some(file) = buffer_ref.file() else {
-            return Task::ready(Err(anyhow!("Buffer has no path.")));
-        };
-
         let Some(project_path) = buffer_ref.project_path(cx) else {
-            return Task::ready(Err(anyhow!("Buffer has no project path.")));
+            return Task::ready(Err(anyhow!("buffer has no path")));
         };
 
         if let Some(symbols_for_path) = self.symbols_by_path.get(&project_path) {
@@ -320,41 +284,39 @@ impl ContextStore {
 
             if let Some(id) = matching_symbol_id {
                 if remove_if_exists {
-                    self.remove_context(id);
+                    self.remove_context(id, cx);
                 }
                 return Task::ready(Ok(false));
             }
         }
 
-        let (buffer_info, collect_content_task) = match collect_buffer_info_and_text(
-            file.path().clone(),
-            buffer,
-            buffer_ref,
-            Some(symbol_enclosing_range.clone()),
-            cx.to_async(),
-        ) {
-            Ok((buffer_info, collect_context_task)) => (buffer_info, collect_context_task),
-            Err(err) => return Task::ready(Err(err)),
-        };
+        let (buffer_info, collect_content_task) =
+            match collect_buffer_info_and_text(buffer, Some(symbol_enclosing_range.clone()), cx) {
+                Ok((buffer_info, collect_context_task)) => (buffer_info, collect_context_task),
+                Err(err) => return Task::ready(Err(err)),
+            };
 
         cx.spawn(async move |this, cx| {
             let content = collect_content_task.await;
 
-            this.update(cx, |this, _cx| {
-                this.insert_symbol(make_context_symbol(
-                    buffer_info,
-                    project_path,
-                    symbol_name,
-                    symbol_range,
-                    symbol_enclosing_range,
-                    content,
-                ))
+            this.update(cx, |this, cx| {
+                this.insert_symbol(
+                    make_context_symbol(
+                        buffer_info,
+                        project_path,
+                        symbol_name,
+                        symbol_range,
+                        symbol_enclosing_range,
+                        content,
+                    ),
+                    cx,
+                )
             })?;
             anyhow::Ok(true)
         })
     }
 
-    fn insert_symbol(&mut self, context_symbol: ContextSymbol) {
+    fn insert_symbol(&mut self, context_symbol: ContextSymbol, cx: &mut Context<Self>) {
         let id = self.next_context_id.post_inc();
         self.symbols.insert(context_symbol.id.clone(), id);
         self.symbols_by_path
@@ -367,6 +329,7 @@ impl ContextStore {
             id,
             context_symbol,
         }));
+        cx.notify();
     }
 
     pub fn add_thread(
@@ -377,7 +340,7 @@ impl ContextStore {
     ) {
         if let Some(context_id) = self.includes_thread(&thread.read(cx).id()) {
             if remove_if_exists {
-                self.remove_context(context_id);
+                self.remove_context(context_id, cx);
             }
         } else {
             self.insert_thread(thread, cx);
@@ -392,14 +355,14 @@ impl ContextStore {
         })
     }
 
-    fn insert_thread(&mut self, thread: Entity<Thread>, cx: &mut App) {
+    fn insert_thread(&mut self, thread: Entity<Thread>, cx: &mut Context<Self>) {
         if let Some(summary_task) =
             thread.update(cx, |thread, cx| thread.generate_detailed_summary(cx))
         {
             let thread = thread.clone();
             let thread_store = self.thread_store.clone();
 
-            self.thread_summary_tasks.push(cx.spawn(async move |cx| {
+            self.thread_summary_tasks.push(cx.spawn(async move |_, cx| {
                 summary_task.await;
 
                 if let Some(thread_store) = thread_store {
@@ -421,15 +384,26 @@ impl ContextStore {
         self.threads.insert(thread.read(cx).id().clone(), id);
         self.context
             .push(AssistantContext::Thread(ThreadContext { id, thread, text }));
+        cx.notify();
     }
 
-    pub fn add_fetched_url(&mut self, url: String, text: impl Into<SharedString>) {
+    pub fn add_fetched_url(
+        &mut self,
+        url: String,
+        text: impl Into<SharedString>,
+        cx: &mut Context<ContextStore>,
+    ) {
         if self.includes_url(&url).is_none() {
-            self.insert_fetched_url(url, text);
+            self.insert_fetched_url(url, text, cx);
         }
     }
 
-    fn insert_fetched_url(&mut self, url: String, text: impl Into<SharedString>) {
+    fn insert_fetched_url(
+        &mut self,
+        url: String,
+        text: impl Into<SharedString>,
+        cx: &mut Context<ContextStore>,
+    ) {
         let id = self.next_context_id.post_inc();
 
         self.fetched_urls.insert(url.clone(), id);
@@ -439,6 +413,7 @@ impl ContextStore {
                 url: url.into(),
                 text: text.into(),
             }));
+        cx.notify();
     }
 
     pub fn accept_suggested_context(
@@ -465,7 +440,7 @@ impl ContextStore {
         Task::ready(Ok(()))
     }
 
-    pub fn remove_context(&mut self, id: ContextId) {
+    pub fn remove_context(&mut self, id: ContextId, cx: &mut Context<Self>) {
         let Some(ix) = self.context.iter().position(|context| context.id() == id) else {
             return;
         };
@@ -497,28 +472,38 @@ impl ContextStore {
                 self.threads.retain(|_, context_id| *context_id != id);
             }
         }
+
+        cx.notify();
     }
 
     /// Returns whether the buffer is already included directly in the context, or if it will be
     /// included in the context via a directory. Directory inclusion is based on paths rather than
     /// buffer IDs as the directory will be re-scanned.
-    pub fn will_include_buffer(&self, buffer_id: BufferId, path: &Path) -> Option<FileInclusion> {
+    pub fn will_include_buffer(
+        &self,
+        buffer_id: BufferId,
+        project_path: &ProjectPath,
+    ) -> Option<FileInclusion> {
         if let Some(context_id) = self.files.get(&buffer_id) {
             return Some(FileInclusion::Direct(*context_id));
         }
 
-        self.will_include_file_path_via_directory(path)
+        self.will_include_file_path_via_directory(project_path)
     }
 
     /// Returns whether this file path is already included directly in the context, or if it will be
     /// included in the context via a directory.
-    pub fn will_include_file_path(&self, path: &Path, cx: &App) -> Option<FileInclusion> {
+    pub fn will_include_file_path(
+        &self,
+        project_path: &ProjectPath,
+        cx: &App,
+    ) -> Option<FileInclusion> {
         if !self.files.is_empty() {
             let found_file_context = self.context.iter().find(|context| match &context {
                 AssistantContext::File(file_context) => {
                     let buffer = file_context.context_buffer.buffer.read(cx);
-                    if let Some(file_path) = buffer_path_log_err(buffer, cx) {
-                        *file_path == *path
+                    if let Some(context_path) = buffer.project_path(cx) {
+                        &context_path == project_path
                     } else {
                         false
                     }
@@ -530,31 +515,40 @@ impl ContextStore {
             }
         }
 
-        self.will_include_file_path_via_directory(path)
+        self.will_include_file_path_via_directory(project_path)
     }
 
-    fn will_include_file_path_via_directory(&self, path: &Path) -> Option<FileInclusion> {
+    fn will_include_file_path_via_directory(
+        &self,
+        project_path: &ProjectPath,
+    ) -> Option<FileInclusion> {
         if self.directories.is_empty() {
             return None;
         }
 
-        let mut buf = path.to_path_buf();
+        let mut path_buf = project_path.path.to_path_buf();
 
-        while buf.pop() {
-            if let Some(_) = self.directories.get(&buf) {
-                return Some(FileInclusion::InDirectory(buf));
+        while path_buf.pop() {
+            // TODO: This isn't very efficient. Consider using a better representation of the
+            // directories map.
+            let directory_project_path = ProjectPath {
+                worktree_id: project_path.worktree_id,
+                path: path_buf.clone().into(),
+            };
+            if let Some(_) = self.directories.get(&directory_project_path) {
+                return Some(FileInclusion::InDirectory(directory_project_path));
             }
         }
 
         None
     }
 
-    pub fn includes_directory(&self, path: &Path) -> Option<FileInclusion> {
-        if let Some(context_id) = self.directories.get(path) {
+    pub fn includes_directory(&self, project_path: &ProjectPath) -> Option<FileInclusion> {
+        if let Some(context_id) = self.directories.get(project_path) {
             return Some(FileInclusion::Direct(*context_id));
         }
 
-        self.will_include_file_path_via_directory(path)
+        self.will_include_file_path_via_directory(project_path)
     }
 
     pub fn included_symbol(&self, symbol_id: &ContextSymbolId) -> Option<ContextId> {
@@ -588,13 +582,13 @@ impl ContextStore {
         }
     }
 
-    pub fn file_paths(&self, cx: &App) -> HashSet<PathBuf> {
+    pub fn file_paths(&self, cx: &App) -> HashSet<ProjectPath> {
         self.context
             .iter()
             .filter_map(|context| match context {
                 AssistantContext::File(file) => {
                     let buffer = file.context_buffer.buffer.read(cx);
-                    buffer_path_log_err(buffer, cx).map(|p| p.to_path_buf())
+                    buffer.project_path(cx)
                 }
                 AssistantContext::Directory(_)
                 | AssistantContext::Symbol(_)
@@ -611,21 +605,21 @@ impl ContextStore {
 
 pub enum FileInclusion {
     Direct(ContextId),
-    InDirectory(PathBuf),
+    InDirectory(ProjectPath),
 }
 
 // ContextBuffer without text.
 struct BufferInfo {
-    buffer_entity: Entity<Buffer>,
-    file: Arc<dyn File>,
     id: BufferId,
+    buffer: Entity<Buffer>,
+    file: Arc<dyn File>,
     version: clock::Global,
 }
 
 fn make_context_buffer(info: BufferInfo, text: SharedString) -> ContextBuffer {
     ContextBuffer {
         id: info.id,
-        buffer: info.buffer_entity,
+        buffer: info.buffer,
         file: info.file,
         version: info.version,
         text,
@@ -644,48 +638,38 @@ fn make_context_symbol(
         id: ContextSymbolId { name, range, path },
         buffer_version: info.version,
         enclosing_range,
-        buffer: info.buffer_entity,
+        buffer: info.buffer,
         text,
     }
 }
 
 fn collect_buffer_info_and_text(
-    path: Arc<Path>,
-    buffer_entity: Entity<Buffer>,
-    buffer: &Buffer,
+    buffer: Entity<Buffer>,
     range: Option<Range<Anchor>>,
-    cx: AsyncApp,
+    cx: &App,
 ) -> Result<(BufferInfo, Task<SharedString>)> {
-    let buffer_info = BufferInfo {
-        id: buffer.remote_id(),
-        buffer_entity,
-        file: buffer
-            .file()
-            .context("buffer context must have a file")?
-            .clone(),
-        version: buffer.version(),
-    };
-    // Important to collect version at the same time as content so that staleness logic is correct.
-    let content = if let Some(range) = range {
-        buffer.text_for_range(range).collect::<Rope>()
-    } else {
-        buffer.as_rope().clone()
-    };
-    let text_task = cx.background_spawn(async move { to_fenced_codeblock(&path, content) });
-    Ok((buffer_info, text_task))
-}
+    let buffer_ref = buffer.read(cx);
+    let file = buffer_ref.file().context("file context must have a path")?;
 
-pub fn buffer_path_log_err(buffer: &Buffer, cx: &App) -> Option<Arc<Path>> {
-    if let Some(file) = buffer.file() {
-        let mut path = file.path().clone();
-        if path.as_os_str().is_empty() {
-            path = file.full_path(cx).into();
-        }
-        Some(path)
+    // Important to collect version at the same time as content so that staleness logic is correct.
+    let version = buffer_ref.version();
+    let content = if let Some(range) = range {
+        buffer_ref.text_for_range(range).collect::<Rope>()
     } else {
-        log::error!("Buffer that had a path unexpectedly no longer has a path.");
-        None
-    }
+        buffer_ref.as_rope().clone()
+    };
+
+    let buffer_info = BufferInfo {
+        buffer,
+        id: buffer_ref.remote_id(),
+        file: file.clone(),
+        version,
+    };
+
+    let full_path = file.full_path(cx);
+    let text_task = cx.background_spawn(async move { to_fenced_codeblock(&full_path, content) });
+
+    Ok((buffer_info, text_task))
 }
 
 fn to_fenced_codeblock(path: &Path, content: Rope) -> SharedString {
@@ -763,13 +747,13 @@ pub fn refresh_context_store_text(
                     }
                 }
                 AssistantContext::Directory(directory_context) => {
+                    let directory_path = directory_context.project_path(cx);
                     let should_refresh = changed_buffers.is_empty()
                         || changed_buffers.iter().any(|buffer| {
-                            let buffer = buffer.read(cx);
-
-                            buffer_path_log_err(&buffer, cx).map_or(false, |path| {
-                                path.starts_with(&directory_context.project_path.path)
-                            })
+                            let Some(buffer_path) = buffer.read(cx).project_path(cx) else {
+                                return false;
+                            };
+                            buffer_path.starts_with(&directory_path)
                         });
 
                     if should_refresh {
@@ -856,14 +840,16 @@ fn refresh_directory_text(
     let context_buffers = future::join_all(futures);
 
     let id = directory_context.id;
-    let project_path = directory_context.project_path.clone();
+    let worktree = directory_context.worktree.clone();
+    let path = directory_context.path.clone();
     Some(cx.spawn(async move |cx| {
         let context_buffers = context_buffers.await;
         context_store
             .update(cx, |context_store, _| {
                 let new_directory_context = DirectoryContext {
                     id,
-                    project_path,
+                    worktree,
+                    path,
                     context_buffers,
                 };
                 context_store.replace_context(AssistantContext::Directory(new_directory_context));
@@ -920,16 +906,9 @@ fn refresh_context_buffer(
     cx: &App,
 ) -> Option<impl Future<Output = ContextBuffer> + use<>> {
     let buffer = context_buffer.buffer.read(cx);
-    let path = buffer_path_log_err(buffer, cx)?;
     if buffer.version.changed_since(&context_buffer.version) {
-        let (buffer_info, text_task) = collect_buffer_info_and_text(
-            path,
-            context_buffer.buffer.clone(),
-            buffer,
-            None,
-            cx.to_async(),
-        )
-        .log_err()?;
+        let (buffer_info, text_task) =
+            collect_buffer_info_and_text(context_buffer.buffer.clone(), None, cx).log_err()?;
         Some(text_task.map(move |text| make_context_buffer(buffer_info, text)))
     } else {
         None
@@ -941,15 +920,12 @@ fn refresh_context_symbol(
     cx: &App,
 ) -> Option<impl Future<Output = ContextSymbol> + use<>> {
     let buffer = context_symbol.buffer.read(cx);
-    let path = buffer_path_log_err(buffer, cx)?;
     let project_path = buffer.project_path(cx)?;
     if buffer.version.changed_since(&context_symbol.buffer_version) {
         let (buffer_info, text_task) = collect_buffer_info_and_text(
-            path,
             context_symbol.buffer.clone(),
-            buffer,
             Some(context_symbol.enclosing_range.clone()),
-            cx.to_async(),
+            cx,
         )
         .log_err()?;
         let name = context_symbol.id.name.clone();

crates/agent/src/context_strip.rs

@@ -1,3 +1,4 @@
+use std::path::Path;
 use std::rc::Rc;
 
 use collections::HashSet;
@@ -9,11 +10,12 @@ use gpui::{
 };
 use itertools::Itertools;
 use language::Buffer;
+use project::ProjectItem;
 use ui::{KeyBinding, PopoverMenu, PopoverMenuHandle, Tooltip, prelude::*};
 use workspace::{Workspace, notifications::NotifyResultExt};
 
 use crate::context::{ContextId, ContextKind};
-use crate::context_picker::{ConfirmBehavior, ContextPicker};
+use crate::context_picker::ContextPicker;
 use crate::context_store::ContextStore;
 use crate::thread::Thread;
 use crate::thread_store::ThreadStore;
@@ -50,7 +52,6 @@ impl ContextStrip {
                 workspace.clone(),
                 thread_store.clone(),
                 context_store.downgrade(),
-                ConfirmBehavior::KeepOpen,
                 window,
                 cx,
             )
@@ -59,6 +60,7 @@ impl ContextStrip {
         let focus_handle = cx.focus_handle();
 
         let subscriptions = vec![
+            cx.observe(&context_store, |_, _, cx| cx.notify()),
             cx.subscribe_in(&context_picker, window, Self::handle_context_picker_event),
             cx.on_focus(&focus_handle, window, Self::handle_focus),
             cx.on_blur(&focus_handle, window, Self::handle_blur),
@@ -92,26 +94,23 @@ impl ContextStrip {
         let active_buffer_entity = editor.buffer().read(cx).as_singleton()?;
         let active_buffer = active_buffer_entity.read(cx);
 
-        let path = active_buffer.file()?.full_path(cx);
+        let project_path = active_buffer.project_path(cx)?;
 
         if self
             .context_store
             .read(cx)
-            .will_include_buffer(active_buffer.remote_id(), &path)
+            .will_include_buffer(active_buffer.remote_id(), &project_path)
             .is_some()
         {
             return None;
         }
 
-        let name = match path.file_name() {
-            Some(name) => name.to_string_lossy().into_owned().into(),
-            None => path.to_string_lossy().into_owned().into(),
-        };
+        let file_name = active_buffer.file()?.file_name(cx);
 
-        let icon_path = FileIcons::get_icon(&path, cx);
+        let icon_path = FileIcons::get_icon(&Path::new(&file_name), cx);
 
         Some(SuggestedContext::File {
-            name,
+            name: file_name.to_string_lossy().into_owned().into(),
             buffer: active_buffer_entity.downgrade(),
             icon_path,
         })
@@ -290,9 +289,9 @@ impl ContextStrip {
         if let Some(index) = self.focused_index {
             let mut is_empty = false;
 
-            self.context_store.update(cx, |this, _cx| {
+            self.context_store.update(cx, |this, cx| {
                 if let Some(item) = this.context().get(index) {
-                    this.remove_context(item.id());
+                    this.remove_context(item.id(), cx);
                 }
 
                 is_empty = this.context().is_empty();
@@ -475,8 +474,8 @@ impl Render for ContextStrip {
                             Some({
                                 let context_store = self.context_store.clone();
                                 Rc::new(cx.listener(move |_this, _event, _window, cx| {
-                                    context_store.update(cx, |this, _cx| {
-                                        this.remove_context(id);
+                                    context_store.update(cx, |this, cx| {
+                                        this.remove_context(id, cx);
                                     });
                                     cx.notify();
                                 }))

crates/agent/src/history_store.rs

@@ -4,6 +4,7 @@ use gpui::{Entity, prelude::*};
 
 use crate::thread_store::{SerializedThreadMetadata, ThreadStore};
 
+#[derive(Debug)]
 pub enum HistoryEntry {
     Thread(SerializedThreadMetadata),
     Context(SavedContextMetadata),
@@ -21,25 +22,27 @@ impl HistoryEntry {
 pub struct HistoryStore {
     thread_store: Entity<ThreadStore>,
     context_store: Entity<assistant_context_editor::ContextStore>,
+    _subscriptions: Vec<gpui::Subscription>,
 }
 
 impl HistoryStore {
     pub fn new(
         thread_store: Entity<ThreadStore>,
         context_store: Entity<assistant_context_editor::ContextStore>,
-        _cx: &mut Context<Self>,
+        cx: &mut Context<Self>,
     ) -> Self {
+        let subscriptions = vec![
+            cx.observe(&thread_store, |_, _, cx| cx.notify()),
+            cx.observe(&context_store, |_, _, cx| cx.notify()),
+        ];
+
         Self {
             thread_store,
             context_store,
+            _subscriptions: subscriptions,
         }
     }
 
-    /// Returns the number of history entries.
-    pub fn entry_count(&self, cx: &mut Context<Self>) -> usize {
-        self.entries(cx).len()
-    }
-
     pub fn entries(&self, cx: &mut Context<Self>) -> Vec<HistoryEntry> {
         let mut history_entries = Vec::new();
 

crates/agent/src/inline_assistant.rs

@@ -28,17 +28,18 @@ use language_model::{LanguageModelRegistry, report_assistant_event};
 use multi_buffer::MultiBufferRow;
 use parking_lot::Mutex;
 use project::LspAction;
+use project::Project;
 use project::{CodeAction, ProjectTransaction};
 use prompt_store::PromptBuilder;
 use settings::{Settings, SettingsStore};
-use telemetry_events::{AssistantEvent, AssistantKind, AssistantPhase};
+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 workspace::{ItemHandle, Toast, Workspace, notifications::NotificationId};
-use workspace::{ShowConfiguration, dock::Panel};
+use workspace::{ItemHandle, Toast, Workspace, dock::Panel, notifications::NotificationId};
+use zed_actions::agent::OpenConfiguration;
 
 use crate::AssistantPanel;
 use crate::buffer_codegen::{BufferCodegen, CodegenAlternative, CodegenEvent};
@@ -239,8 +240,8 @@ impl InlineAssistant {
 
         let is_authenticated = || {
             LanguageModelRegistry::read_global(cx)
-                .active_provider()
-                .map_or(false, |provider| provider.is_authenticated(cx))
+                .inline_assistant_model()
+                .map_or(false, |model| model.provider.is_authenticated(cx))
         };
 
         let thread_store = workspace
@@ -254,6 +255,7 @@ impl InlineAssistant {
                         assistant.assist(
                             &active_editor,
                             cx.entity().downgrade(),
+                            workspace.project().downgrade(),
                             thread_store,
                             window,
                             cx,
@@ -265,6 +267,7 @@ impl InlineAssistant {
                         assistant.assist(
                             &active_terminal,
                             cx.entity().downgrade(),
+                            workspace.project().downgrade(),
                             thread_store,
                             window,
                             cx,
@@ -279,8 +282,8 @@ impl InlineAssistant {
             cx.spawn_in(window, async move |_workspace, cx| {
                 let Some(task) = cx.update(|_, cx| {
                     LanguageModelRegistry::read_global(cx)
-                        .active_provider()
-                        .map_or(None, |provider| Some(provider.authenticate(cx)))
+                        .inline_assistant_model()
+                        .map_or(None, |model| Some(model.provider.authenticate(cx)))
                 })?
                 else {
                     let answer = cx
@@ -295,7 +298,7 @@ impl InlineAssistant {
                     if let Some(answer) = answer {
                         if answer == 0 {
                             cx.update(|window, cx| {
-                                window.dispatch_action(Box::new(ShowConfiguration), cx)
+                                window.dispatch_action(Box::new(OpenConfiguration), cx)
                             })
                             .ok();
                         }
@@ -318,6 +321,7 @@ impl InlineAssistant {
         &mut self,
         editor: &Entity<Editor>,
         workspace: WeakEntity<Workspace>,
+        project: WeakEntity<Project>,
         thread_store: Option<WeakEntity<ThreadStore>>,
         window: &mut Window,
         cx: &mut App,
@@ -401,14 +405,14 @@ impl InlineAssistant {
 
             codegen_ranges.push(anchor_range);
 
-            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
-                self.telemetry.report_assistant_event(AssistantEvent {
+            if let Some(model) = LanguageModelRegistry::read_global(cx).inline_assistant_model() {
+                self.telemetry.report_assistant_event(AssistantEventData {
                     conversation_id: None,
                     kind: AssistantKind::Inline,
                     phase: AssistantPhase::Invoked,
                     message_id: None,
-                    model: model.telemetry_id(),
-                    model_provider: model.provider_id().to_string(),
+                    model: model.model.telemetry_id(),
+                    model_provider: model.provider.id().to_string(),
                     response_latency: None,
                     error_message: None,
                     language_name: buffer.language().map(|language| language.name().to_proto()),
@@ -425,7 +429,7 @@ impl InlineAssistant {
         for range in codegen_ranges {
             let assist_id = self.next_assist_id.post_inc();
             let context_store =
-                cx.new(|_cx| ContextStore::new(workspace.clone(), thread_store.clone()));
+                cx.new(|_cx| ContextStore::new(project.clone(), thread_store.clone()));
             let codegen = cx.new(|cx| {
                 BufferCodegen::new(
                     editor.read(cx).buffer().clone(),
@@ -519,7 +523,7 @@ impl InlineAssistant {
         initial_prompt: String,
         initial_transaction_id: Option<TransactionId>,
         focus: bool,
-        workspace: WeakEntity<Workspace>,
+        workspace: Entity<Workspace>,
         thread_store: Option<WeakEntity<ThreadStore>>,
         window: &mut Window,
         cx: &mut App,
@@ -537,8 +541,8 @@ impl InlineAssistant {
             range.end = range.end.bias_right(&snapshot);
         }
 
-        let context_store =
-            cx.new(|_cx| ContextStore::new(workspace.clone(), thread_store.clone()));
+        let project = workspace.read(cx).project().downgrade();
+        let context_store = cx.new(|_cx| ContextStore::new(project, thread_store.clone()));
 
         let codegen = cx.new(|cx| {
             BufferCodegen::new(
@@ -562,7 +566,7 @@ impl InlineAssistant {
                 codegen.clone(),
                 self.fs.clone(),
                 context_store,
-                workspace.clone(),
+                workspace.downgrade(),
                 thread_store,
                 window,
                 cx,
@@ -589,7 +593,7 @@ impl InlineAssistant {
                 end_block_id,
                 range,
                 codegen.clone(),
-                workspace.clone(),
+                workspace.downgrade(),
                 window,
                 cx,
             ),
@@ -621,14 +625,14 @@ impl InlineAssistant {
             BlockProperties {
                 style: BlockStyle::Sticky,
                 placement: BlockPlacement::Above(range.start),
-                height: prompt_editor_height,
+                height: Some(prompt_editor_height),
                 render: build_assist_editor_renderer(prompt_editor),
                 priority: 0,
             },
             BlockProperties {
                 style: BlockStyle::Sticky,
                 placement: BlockPlacement::Below(range.end),
-                height: 0,
+                height: None,
                 render: Arc::new(|cx| {
                     v_flex()
                         .h_full()
@@ -976,7 +980,7 @@ impl InlineAssistant {
             let active_alternative = assist.codegen.read(cx).active_alternative().clone();
             let message_id = active_alternative.read(cx).message_id.clone();
 
-            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
+            if let Some(model) = LanguageModelRegistry::read_global(cx).inline_assistant_model() {
                 let language_name = assist.editor.upgrade().and_then(|editor| {
                     let multibuffer = editor.read(cx).buffer().read(cx);
                     let snapshot = multibuffer.snapshot(cx);
@@ -987,7 +991,7 @@ impl InlineAssistant {
                         .map(|language| language.name())
                 });
                 report_assistant_event(
-                    AssistantEvent {
+                    AssistantEventData {
                         conversation_id: None,
                         kind: AssistantKind::Inline,
                         message_id,
@@ -996,15 +1000,15 @@ impl InlineAssistant {
                         } else {
                             AssistantPhase::Accepted
                         },
-                        model: model.telemetry_id(),
-                        model_provider: model.provider_id().to_string(),
+                        model: model.model.telemetry_id(),
+                        model_provider: model.model.provider_id().to_string(),
                         response_latency: None,
                         error_message: None,
                         language_name: language_name.map(|name| name.to_proto()),
                     },
                     Some(self.telemetry.clone()),
                     cx.http_client(),
-                    model.api_key(cx),
+                    model.model.api_key(cx),
                     cx.background_executor(),
                 );
             }
@@ -1392,7 +1396,7 @@ impl InlineAssistant {
                     deleted_lines_editor.update(cx, |editor, cx| editor.max_point(cx).row().0 + 1);
                 new_blocks.push(BlockProperties {
                     placement: BlockPlacement::Above(new_row),
-                    height,
+                    height: Some(height),
                     style: BlockStyle::Flex,
                     render: Arc::new(move |cx| {
                         div()
@@ -1779,6 +1783,7 @@ impl CodeActionProvider for AssistantCodeActionProvider {
         let workspace = self.workspace.clone();
         let thread_store = self.thread_store.clone();
         window.spawn(cx, async move |cx| {
+            let workspace = workspace.upgrade().context("workspace was released")?;
             let editor = editor.upgrade().context("editor was released")?;
             let range = editor
                 .update(cx, |editor, cx| {

crates/agent/src/inline_prompt_editor.rs

@@ -1,4 +1,4 @@
-use crate::assistant_model_selector::AssistantModelSelector;
+use crate::assistant_model_selector::{AssistantModelSelector, ModelType};
 use crate::buffer_codegen::BufferCodegen;
 use crate::context_picker::ContextPicker;
 use crate::context_store::ContextStore;
@@ -582,7 +582,7 @@ impl<T: 'static> PromptEditor<T> {
         let disabled = matches!(codegen.status(cx), CodegenStatus::Idle);
 
         let model_registry = LanguageModelRegistry::read_global(cx);
-        let default_model = model_registry.active_model();
+        let default_model = model_registry.default_model().map(|default| default.model);
         let alternative_models = model_registry.inline_alternative_models();
 
         let get_model_name = |index: usize| -> String {
@@ -890,6 +890,7 @@ impl PromptEditor<BufferCodegen> {
                     fs,
                     model_selector_menu_handle,
                     prompt_editor.focus_handle(cx),
+                    ModelType::InlineAssistant,
                     window,
                     cx,
                 )
@@ -1042,6 +1043,7 @@ impl PromptEditor<TerminalCodegen> {
                     fs,
                     model_selector_menu_handle.clone(),
                     prompt_editor.focus_handle(cx),
+                    ModelType::InlineAssistant,
                     window,
                     cx,
                 )

crates/agent/src/profile_selector.rs

@@ -130,8 +130,8 @@ impl Render for ProfileSelector {
 
         let model_registry = LanguageModelRegistry::read_global(cx);
         let supports_tools = model_registry
-            .active_model()
-            .map_or(false, |model| model.supports_tools());
+            .default_model()
+            .map_or(false, |default| default.model.supports_tools());
 
         let icon = match profile_id.as_str() {
             "write" => IconName::Pencil,

crates/agent/src/terminal_codegen.rs

@@ -2,9 +2,11 @@ use crate::inline_prompt_editor::CodegenStatus;
 use client::telemetry::Telemetry;
 use futures::{SinkExt, StreamExt, channel::mpsc};
 use gpui::{App, AppContext as _, Context, Entity, EventEmitter, Task};
-use language_model::{LanguageModelRegistry, LanguageModelRequest, report_assistant_event};
+use language_model::{
+    ConfiguredModel, LanguageModelRegistry, LanguageModelRequest, report_assistant_event,
+};
 use std::{sync::Arc, time::Instant};
-use telemetry_events::{AssistantEvent, AssistantKind, AssistantPhase};
+use telemetry_events::{AssistantEventData, AssistantKind, AssistantPhase};
 use terminal::Terminal;
 
 pub struct TerminalCodegen {
@@ -31,7 +33,9 @@ impl TerminalCodegen {
     }
 
     pub fn start(&mut self, prompt: LanguageModelRequest, cx: &mut Context<Self>) {
-        let Some(model) = LanguageModelRegistry::read_global(cx).active_model() else {
+        let Some(ConfiguredModel { model, .. }) =
+            LanguageModelRegistry::read_global(cx).inline_assistant_model()
+        else {
             return;
         };
 
@@ -75,7 +79,7 @@ impl TerminalCodegen {
 
                         let error_message = result.as_ref().err().map(|error| error.to_string());
                         report_assistant_event(
-                            AssistantEvent {
+                            AssistantEventData {
                                 conversation_id: None,
                                 kind: AssistantKind::InlineTerminal,
                                 message_id,

crates/agent/src/terminal_inline_assistant.rs

@@ -13,12 +13,13 @@ use fs::Fs;
 use gpui::{App, Entity, Focusable, Global, Subscription, UpdateGlobal, WeakEntity};
 use language::Buffer;
 use language_model::{
-    LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage, Role,
-    report_assistant_event,
+    ConfiguredModel, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage,
+    Role, report_assistant_event,
 };
+use project::Project;
 use prompt_store::PromptBuilder;
 use std::sync::Arc;
-use telemetry_events::{AssistantEvent, AssistantKind, AssistantPhase};
+use telemetry_events::{AssistantEventData, AssistantKind, AssistantPhase};
 use terminal_view::TerminalView;
 use ui::prelude::*;
 use util::ResultExt;
@@ -67,6 +68,7 @@ impl TerminalInlineAssistant {
         &mut self,
         terminal_view: &Entity<TerminalView>,
         workspace: WeakEntity<Workspace>,
+        project: WeakEntity<Project>,
         thread_store: Option<WeakEntity<ThreadStore>>,
         window: &mut Window,
         cx: &mut App,
@@ -75,8 +77,7 @@ impl TerminalInlineAssistant {
         let assist_id = self.next_assist_id.post_inc();
         let prompt_buffer =
             cx.new(|cx| MultiBuffer::singleton(cx.new(|cx| Buffer::local(String::new(), cx)), cx));
-        let context_store =
-            cx.new(|_cx| ContextStore::new(workspace.clone(), thread_store.clone()));
+        let context_store = cx.new(|_cx| ContextStore::new(project, thread_store.clone()));
         let codegen = cx.new(|_| TerminalCodegen::new(terminal, self.telemetry.clone()));
 
         let prompt_editor = cx.new(|cx| {
@@ -286,11 +287,13 @@ impl TerminalInlineAssistant {
                 })
                 .log_err();
 
-            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
+            if let Some(ConfiguredModel { model, .. }) =
+                LanguageModelRegistry::read_global(cx).inline_assistant_model()
+            {
                 let codegen = assist.codegen.read(cx);
                 let executor = cx.background_executor().clone();
                 report_assistant_event(
-                    AssistantEvent {
+                    AssistantEventData {
                         conversation_id: None,
                         kind: AssistantKind::InlineTerminal,
                         message_id: codegen.message_id.clone(),

crates/agent/src/thread_history.rs

@@ -1,52 +1,189 @@
+use std::sync::Arc;
+
 use assistant_context_editor::SavedContextMetadata;
+use editor::{Editor, EditorEvent};
+use fuzzy::{StringMatch, StringMatchCandidate};
 use gpui::{
-    App, Entity, FocusHandle, Focusable, ScrollStrategy, UniformListScrollHandle, WeakEntity,
-    uniform_list,
+    App, Entity, FocusHandle, Focusable, ScrollStrategy, Stateful, Task, UniformListScrollHandle,
+    WeakEntity, Window, uniform_list,
 };
 use time::{OffsetDateTime, UtcOffset};
-use ui::{IconButtonShape, ListItem, ListItemSpacing, Tooltip, prelude::*};
+use ui::{
+    HighlightedLabel, IconButtonShape, ListItem, ListItemSpacing, Scrollbar, ScrollbarState,
+    Tooltip, prelude::*,
+};
+use util::ResultExt;
 
 use crate::history_store::{HistoryEntry, HistoryStore};
 use crate::thread_store::SerializedThreadMetadata;
 use crate::{AssistantPanel, RemoveSelectedThread};
 
 pub struct ThreadHistory {
-    focus_handle: FocusHandle,
     assistant_panel: WeakEntity<AssistantPanel>,
     history_store: Entity<HistoryStore>,
     scroll_handle: UniformListScrollHandle,
     selected_index: usize,
+    search_query: SharedString,
+    search_editor: Entity<Editor>,
+    all_entries: Arc<Vec<HistoryEntry>>,
+    matches: Vec<StringMatch>,
+    _subscriptions: Vec<gpui::Subscription>,
+    _search_task: Option<Task<()>>,
+    scrollbar_visibility: bool,
+    scrollbar_state: ScrollbarState,
 }
 
 impl ThreadHistory {
     pub(crate) fn new(
         assistant_panel: WeakEntity<AssistantPanel>,
         history_store: Entity<HistoryStore>,
+        window: &mut Window,
         cx: &mut Context<Self>,
     ) -> Self {
+        let search_editor = cx.new(|cx| {
+            let mut editor = Editor::single_line(window, cx);
+            editor.set_placeholder_text("Search threads...", cx);
+            editor
+        });
+
+        let search_editor_subscription =
+            cx.subscribe(&search_editor, |this, search_editor, event, cx| {
+                if let EditorEvent::BufferEdited = event {
+                    let query = search_editor.read(cx).text(cx);
+                    this.search_query = query.into();
+                    this.update_search(cx);
+                }
+            });
+
+        let entries: Arc<Vec<_>> = history_store
+            .update(cx, |store, cx| store.entries(cx))
+            .into();
+
+        let history_store_subscription = cx.observe(&history_store, |this, _, cx| {
+            this.update_all_entries(cx);
+        });
+
+        let scroll_handle = UniformListScrollHandle::default();
+        let scrollbar_state = ScrollbarState::new(scroll_handle.clone());
+
         Self {
-            focus_handle: cx.focus_handle(),
             assistant_panel,
             history_store,
-            scroll_handle: UniformListScrollHandle::default(),
+            scroll_handle,
             selected_index: 0,
+            search_query: SharedString::new_static(""),
+            all_entries: entries,
+            matches: Vec::new(),
+            search_editor,
+            _subscriptions: vec![search_editor_subscription, history_store_subscription],
+            _search_task: None,
+            scrollbar_visibility: true,
+            scrollbar_state,
+        }
+    }
+
+    fn update_all_entries(&mut self, cx: &mut Context<Self>) {
+        self.all_entries = self
+            .history_store
+            .update(cx, |store, cx| store.entries(cx))
+            .into();
+        self.matches.clear();
+        self.update_search(cx);
+    }
+
+    fn update_search(&mut self, cx: &mut Context<Self>) {
+        self._search_task.take();
+
+        if self.has_search_query() {
+            self.perform_search(cx);
+        } else {
+            self.matches.clear();
+            self.set_selected_index(0, cx);
+            cx.notify();
+        }
+    }
+
+    fn perform_search(&mut self, cx: &mut Context<Self>) {
+        let query = self.search_query.clone();
+        let all_entries = self.all_entries.clone();
+
+        let task = cx.spawn(async move |this, cx| {
+            let executor = cx.background_executor().clone();
+
+            let matches = cx
+                .background_spawn(async move {
+                    let mut candidates = Vec::with_capacity(all_entries.len());
+
+                    for (idx, entry) in all_entries.iter().enumerate() {
+                        match entry {
+                            HistoryEntry::Thread(thread) => {
+                                candidates.push(StringMatchCandidate::new(idx, &thread.summary));
+                            }
+                            HistoryEntry::Context(context) => {
+                                candidates.push(StringMatchCandidate::new(idx, &context.title));
+                            }
+                        }
+                    }
+
+                    const MAX_MATCHES: usize = 100;
+
+                    fuzzy::match_strings(
+                        &candidates,
+                        &query,
+                        false,
+                        MAX_MATCHES,
+                        &Default::default(),
+                        executor,
+                    )
+                    .await
+                })
+                .await;
+
+            this.update(cx, |this, cx| {
+                this.matches = matches;
+                this.set_selected_index(0, cx);
+                cx.notify();
+            })
+            .log_err();
+        });
+
+        self._search_task = Some(task);
+    }
+
+    fn has_search_query(&self) -> bool {
+        !self.search_query.is_empty()
+    }
+
+    fn matched_count(&self) -> usize {
+        if self.has_search_query() {
+            self.matches.len()
+        } else {
+            self.all_entries.len()
+        }
+    }
+
+    fn get_match(&self, ix: usize) -> Option<&HistoryEntry> {
+        if self.has_search_query() {
+            self.matches
+                .get(ix)
+                .and_then(|m| self.all_entries.get(m.candidate_id))
+        } else {
+            self.all_entries.get(ix)
         }
     }
 
     pub fn select_previous(
         &mut self,
         _: &menu::SelectPrevious,
-        window: &mut Window,
+        _window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        let count = self
-            .history_store
-            .update(cx, |this, cx| this.entry_count(cx));
+        let count = self.matched_count();
         if count > 0 {
             if self.selected_index == 0 {
-                self.set_selected_index(count - 1, window, cx);
+                self.set_selected_index(count - 1, cx);
             } else {
-                self.set_selected_index(self.selected_index - 1, window, cx);
+                self.set_selected_index(self.selected_index - 1, cx);
             }
         }
     }
@@ -54,64 +191,98 @@ impl ThreadHistory {
     pub fn select_next(
         &mut self,
         _: &menu::SelectNext,
-        window: &mut Window,
+        _window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        let count = self
-            .history_store
-            .update(cx, |this, cx| this.entry_count(cx));
+        let count = self.matched_count();
         if count > 0 {
             if self.selected_index == count - 1 {
-                self.set_selected_index(0, window, cx);
+                self.set_selected_index(0, cx);
             } else {
-                self.set_selected_index(self.selected_index + 1, window, cx);
+                self.set_selected_index(self.selected_index + 1, cx);
             }
         }
     }
 
-    fn select_first(&mut self, _: &menu::SelectFirst, window: &mut Window, cx: &mut Context<Self>) {
-        let count = self
-            .history_store
-            .update(cx, |this, cx| this.entry_count(cx));
+    fn select_first(
+        &mut self,
+        _: &menu::SelectFirst,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let count = self.matched_count();
         if count > 0 {
-            self.set_selected_index(0, window, cx);
+            self.set_selected_index(0, cx);
         }
     }
 
-    fn select_last(&mut self, _: &menu::SelectLast, window: &mut Window, cx: &mut Context<Self>) {
-        let count = self
-            .history_store
-            .update(cx, |this, cx| this.entry_count(cx));
+    fn select_last(&mut self, _: &menu::SelectLast, _window: &mut Window, cx: &mut Context<Self>) {
+        let count = self.matched_count();
         if count > 0 {
-            self.set_selected_index(count - 1, window, cx);
+            self.set_selected_index(count - 1, cx);
         }
     }
 
-    fn set_selected_index(&mut self, index: usize, _window: &mut Window, cx: &mut Context<Self>) {
+    fn set_selected_index(&mut self, index: usize, cx: &mut Context<Self>) {
         self.selected_index = index;
         self.scroll_handle
             .scroll_to_item(index, ScrollStrategy::Top);
         cx.notify();
     }
 
-    fn confirm(&mut self, _: &menu::Confirm, window: &mut Window, cx: &mut Context<Self>) {
-        let entries = self.history_store.update(cx, |this, cx| this.entries(cx));
+    fn render_scrollbar(&self, cx: &mut Context<Self>) -> Option<Stateful<Div>> {
+        if !(self.scrollbar_visibility || self.scrollbar_state.is_dragging()) {
+            return None;
+        }
 
-        if let Some(entry) = entries.get(self.selected_index) {
-            match entry {
-                HistoryEntry::Thread(thread) => {
-                    self.assistant_panel
-                        .update(cx, move |this, cx| this.open_thread(&thread.id, window, cx))
-                        .ok();
-                }
+        Some(
+            div()
+                .occlude()
+                .id("thread-history-scroll")
+                .h_full()
+                .bg(cx.theme().colors().panel_background.opacity(0.8))
+                .border_l_1()
+                .border_color(cx.theme().colors().border_variant)
+                .absolute()
+                .right_1()
+                .top_0()
+                .bottom_0()
+                .w_4()
+                .pl_1()
+                .cursor_default()
+                .on_mouse_move(cx.listener(|_, _, _window, cx| {
+                    cx.notify();
+                    cx.stop_propagation()
+                }))
+                .on_hover(|_, _window, cx| {
+                    cx.stop_propagation();
+                })
+                .on_any_mouse_down(|_, _window, cx| {
+                    cx.stop_propagation();
+                })
+                .on_scroll_wheel(cx.listener(|_, _, _window, cx| {
+                    cx.notify();
+                }))
+                .children(Scrollbar::vertical(self.scrollbar_state.clone())),
+        )
+    }
+
+    fn confirm(&mut self, _: &menu::Confirm, window: &mut Window, cx: &mut Context<Self>) {
+        if let Some(entry) = self.get_match(self.selected_index) {
+            let task_result = match entry {
+                HistoryEntry::Thread(thread) => self
+                    .assistant_panel
+                    .update(cx, move |this, cx| this.open_thread(&thread.id, window, cx)),
                 HistoryEntry::Context(context) => {
-                    self.assistant_panel
-                        .update(cx, move |this, cx| {
-                            this.open_saved_prompt_editor(context.path.clone(), window, cx)
-                        })
-                        .ok();
+                    self.assistant_panel.update(cx, move |this, cx| {
+                        this.open_saved_prompt_editor(context.path.clone(), window, cx)
+                    })
                 }
-            }
+            };
+
+            if let Some(task) = task_result.log_err() {
+                task.detach_and_log_err(cx);
+            };
 
             cx.notify();
         }
@@ -123,25 +294,19 @@ impl ThreadHistory {
         _window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        let entries = self.history_store.update(cx, |this, cx| this.entries(cx));
+        if let Some(entry) = self.get_match(self.selected_index) {
+            let task_result = match entry {
+                HistoryEntry::Thread(thread) => self
+                    .assistant_panel
+                    .update(cx, |this, cx| this.delete_thread(&thread.id, cx)),
+                HistoryEntry::Context(context) => self
+                    .assistant_panel
+                    .update(cx, |this, cx| this.delete_context(context.path.clone(), cx)),
+            };
 
-        if let Some(entry) = entries.get(self.selected_index) {
-            match entry {
-                HistoryEntry::Thread(thread) => {
-                    self.assistant_panel
-                        .update(cx, |this, cx| {
-                            this.delete_thread(&thread.id, cx);
-                        })
-                        .ok();
-                }
-                HistoryEntry::Context(context) => {
-                    self.assistant_panel
-                        .update(cx, |this, cx| {
-                            this.delete_context(context.path.clone(), cx);
-                        })
-                        .ok();
-                }
-            }
+            if let Some(task) = task_result.log_err() {
+                task.detach_and_log_err(cx);
+            };
 
             cx.notify();
         }
@@ -149,71 +314,129 @@ impl ThreadHistory {
 }
 
 impl Focusable for ThreadHistory {
-    fn focus_handle(&self, _cx: &App) -> FocusHandle {
-        self.focus_handle.clone()
+    fn focus_handle(&self, cx: &App) -> FocusHandle {
+        self.search_editor.focus_handle(cx)
     }
 }
 
 impl Render for ThreadHistory {
     fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let history_entries = self.history_store.update(cx, |this, cx| this.entries(cx));
         let selected_index = self.selected_index;
 
         v_flex()
-            .id("thread-history-container")
             .key_context("ThreadHistory")
-            .track_focus(&self.focus_handle)
-            .overflow_y_scroll()
             .size_full()
-            .p_1()
             .on_action(cx.listener(Self::select_previous))
             .on_action(cx.listener(Self::select_next))
             .on_action(cx.listener(Self::select_first))
             .on_action(cx.listener(Self::select_last))
             .on_action(cx.listener(Self::confirm))
             .on_action(cx.listener(Self::remove_selected_thread))
-            .map(|history| {
-                if history_entries.is_empty() {
-                    history
-                        .justify_center()
+            .when(!self.all_entries.is_empty(), |parent| {
+                parent.child(
+                    h_flex()
+                        .h(px(41.)) // Match the toolbar perfectly
+                        .w_full()
+                        .py_1()
+                        .px_2()
+                        .gap_2()
+                        .justify_between()
+                        .border_b_1()
+                        .border_color(cx.theme().colors().border)
+                        .child(
+                            Icon::new(IconName::MagnifyingGlass)
+                                .color(Color::Muted)
+                                .size(IconSize::Small),
+                        )
+                        .child(self.search_editor.clone()),
+                )
+            })
+            .child({
+                let view = v_flex()
+                    .id("list-container")
+                    .relative()
+                    .overflow_hidden()
+                    .flex_grow();
+
+                if self.all_entries.is_empty() {
+                    view.justify_center()
                         .child(
                             h_flex().w_full().justify_center().child(
                                 Label::new("You don't have any past threads yet.")
                                     .size(LabelSize::Small),
                             ),
                         )
+                } else if self.has_search_query() && self.matches.is_empty() {
+                    view.justify_center().child(
+                        h_flex().w_full().justify_center().child(
+                            Label::new("No threads match your search.").size(LabelSize::Small),
+                        ),
+                    )
                 } else {
-                    history.child(
-                        uniform_list(
-                            cx.entity().clone(),
-                            "thread-history",
-                            history_entries.len(),
-                            move |history, range, _window, _cx| {
-                                history_entries[range]
-                                    .iter()
-                                    .enumerate()
-                                    .map(|(index, entry)| {
+                    view.pr_5()
+                        .child(
+                            uniform_list(
+                                cx.entity().clone(),
+                                "thread-history",
+                                self.matched_count(),
+                                move |history, range, _window, _cx| {
+                                    let range_start = range.start;
+                                    let assistant_panel = history.assistant_panel.clone();
+
+                                    let render_item = |index: usize,
+                                                       entry: &HistoryEntry,
+                                                       highlight_positions: Vec<usize>|
+                                     -> Div {
                                         h_flex().w_full().pb_1().child(match entry {
                                             HistoryEntry::Thread(thread) => PastThread::new(
                                                 thread.clone(),
-                                                history.assistant_panel.clone(),
-                                                selected_index == index,
+                                                assistant_panel.clone(),
+                                                selected_index == index + range_start,
+                                                highlight_positions,
                                             )
                                             .into_any_element(),
                                             HistoryEntry::Context(context) => PastContext::new(
                                                 context.clone(),
-                                                history.assistant_panel.clone(),
-                                                selected_index == index,
+                                                assistant_panel.clone(),
+                                                selected_index == index + range_start,
+                                                highlight_positions,
                                             )
                                             .into_any_element(),
                                         })
-                                    })
-                                    .collect()
-                            },
+                                    };
+
+                                    if history.has_search_query() {
+                                        history.matches[range]
+                                            .iter()
+                                            .enumerate()
+                                            .filter_map(|(index, m)| {
+                                                history.all_entries.get(m.candidate_id).map(
+                                                    |entry| {
+                                                        render_item(
+                                                            index,
+                                                            entry,
+                                                            m.positions.clone(),
+                                                        )
+                                                    },
+                                                )
+                                            })
+                                            .collect()
+                                    } else {
+                                        history.all_entries[range]
+                                            .iter()
+                                            .enumerate()
+                                            .map(|(index, entry)| render_item(index, entry, vec![]))
+                                            .collect()
+                                    }
+                                },
+                            )
+                            .p_1()
+                            .track_scroll(self.scroll_handle.clone())
+                            .flex_grow(),
                         )
-                        .track_scroll(self.scroll_handle.clone())
-                        .flex_grow(),
-                    )
+                        .when_some(self.render_scrollbar(cx), |div, scrollbar| {
+                            div.child(scrollbar)
+                        })
                 }
             })
     }
@@ -224,6 +447,7 @@ pub struct PastThread {
     thread: SerializedThreadMetadata,
     assistant_panel: WeakEntity<AssistantPanel>,
     selected: bool,
+    highlight_positions: Vec<usize>,
 }
 
 impl PastThread {
@@ -231,11 +455,13 @@ impl PastThread {
         thread: SerializedThreadMetadata,
         assistant_panel: WeakEntity<AssistantPanel>,
         selected: bool,
+        highlight_positions: Vec<usize>,
     ) -> Self {
         Self {
             thread,
             assistant_panel,
             selected,
+            highlight_positions,
         }
     }
 }
@@ -258,24 +484,15 @@ impl RenderOnce for PastThread {
             .toggle_state(self.selected)
             .spacing(ListItemSpacing::Sparse)
             .start_slot(
-                div()
-                    .max_w_4_5()
-                    .child(Label::new(summary).size(LabelSize::Small).truncate()),
+                div().max_w_4_5().child(
+                    HighlightedLabel::new(summary, self.highlight_positions)
+                        .size(LabelSize::Small)
+                        .truncate(),
+                ),
             )
             .end_slot(
                 h_flex()
                     .gap_1p5()
-                    .child(
-                        Label::new("Thread")
-                            .color(Color::Muted)
-                            .size(LabelSize::XSmall),
-                    )
-                    .child(
-                        div()
-                            .size(px(3.))
-                            .rounded_full()
-                            .bg(cx.theme().colors().text_disabled),
-                    )
                     .child(
                         Label::new(thread_timestamp)
                             .color(Color::Muted)
@@ -285,14 +502,17 @@ impl RenderOnce for PastThread {
                         IconButton::new("delete", IconName::TrashAlt)
                             .shape(IconButtonShape::Square)
                             .icon_size(IconSize::XSmall)
-                            .tooltip(Tooltip::text("Delete Thread"))
+                            .icon_color(Color::Muted)
+                            .tooltip(move |window, cx| {
+                                Tooltip::for_action("Delete", &RemoveSelectedThread, window, cx)
+                            })
                             .on_click({
                                 let assistant_panel = self.assistant_panel.clone();
                                 let id = self.thread.id.clone();
                                 move |_event, _window, cx| {
                                     assistant_panel
                                         .update(cx, |this, cx| {
-                                            this.delete_thread(&id, cx);
+                                            this.delete_thread(&id, cx).detach_and_log_err(cx);
                                         })
                                         .ok();
                                 }
@@ -318,6 +538,7 @@ pub struct PastContext {
     context: SavedContextMetadata,
     assistant_panel: WeakEntity<AssistantPanel>,
     selected: bool,
+    highlight_positions: Vec<usize>,
 }
 
 impl PastContext {
@@ -325,11 +546,13 @@ impl PastContext {
         context: SavedContextMetadata,
         assistant_panel: WeakEntity<AssistantPanel>,
         selected: bool,
+        highlight_positions: Vec<usize>,
     ) -> Self {
         Self {
             context,
             assistant_panel,
             selected,
+            highlight_positions,
         }
     }
 }
@@ -337,7 +560,6 @@ impl PastContext {
 impl RenderOnce for PastContext {
     fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
         let summary = self.context.title;
-
         let context_timestamp = time_format::format_localized_timestamp(
             OffsetDateTime::from_unix_timestamp(self.context.mtime.timestamp()).unwrap(),
             OffsetDateTime::now_utc(),
@@ -354,24 +576,15 @@ impl RenderOnce for PastContext {
         .toggle_state(self.selected)
         .spacing(ListItemSpacing::Sparse)
         .start_slot(
-            div()
-                .max_w_4_5()
-                .child(Label::new(summary).size(LabelSize::Small).truncate()),
+            div().max_w_4_5().child(
+                HighlightedLabel::new(summary, self.highlight_positions)
+                    .size(LabelSize::Small)
+                    .truncate(),
+            ),
         )
         .end_slot(
             h_flex()
                 .gap_1p5()
-                .child(
-                    Label::new("Prompt Editor")
-                        .color(Color::Muted)
-                        .size(LabelSize::XSmall),
-                )
-                .child(
-                    div()
-                        .size(px(3.))
-                        .rounded_full()
-                        .bg(cx.theme().colors().text_disabled),
-                )
                 .child(
                     Label::new(context_timestamp)
                         .color(Color::Muted)
@@ -381,14 +594,18 @@ impl RenderOnce for PastContext {
                     IconButton::new("delete", IconName::TrashAlt)
                         .shape(IconButtonShape::Square)
                         .icon_size(IconSize::XSmall)
-                        .tooltip(Tooltip::text("Delete Prompt Editor"))
+                        .icon_color(Color::Muted)
+                        .tooltip(move |window, cx| {
+                            Tooltip::for_action("Delete", &RemoveSelectedThread, window, cx)
+                        })
                         .on_click({
                             let assistant_panel = self.assistant_panel.clone();
                             let path = self.context.path.clone();
                             move |_event, _window, cx| {
                                 assistant_panel
                                     .update(cx, |this, cx| {
-                                        this.delete_context(path.clone(), cx);
+                                        this.delete_context(path.clone(), cx)
+                                            .detach_and_log_err(cx);
                                     })
                                     .ok();
                             }

crates/agent/src/thread_store.rs

@@ -1,37 +1,59 @@
 use std::borrow::Cow;
-use std::path::PathBuf;
+use std::cell::{Ref, RefCell};
+use std::path::{Path, PathBuf};
+use std::rc::Rc;
 use std::sync::Arc;
 
-use anyhow::{Result, anyhow};
+use anyhow::{Context as _, Result, anyhow};
 use assistant_settings::{AgentProfile, AgentProfileId, AssistantSettings};
 use assistant_tool::{ToolId, ToolSource, ToolWorkingSet};
 use chrono::{DateTime, Utc};
 use collections::HashMap;
 use context_server::manager::ContextServerManager;
 use context_server::{ContextServerFactoryRegistry, ContextServerTool};
+use fs::Fs;
 use futures::FutureExt as _;
 use futures::future::{self, BoxFuture, Shared};
 use gpui::{
-    App, BackgroundExecutor, Context, Entity, Global, ReadGlobal, SharedString, Subscription, Task,
-    prelude::*,
+    App, BackgroundExecutor, Context, Entity, EventEmitter, Global, ReadGlobal, SharedString,
+    Subscription, Task, prelude::*,
 };
 use heed::Database;
 use heed::types::SerdeBincode;
 use language_model::{LanguageModelToolUseId, Role, TokenUsage};
-use project::Project;
-use prompt_store::PromptBuilder;
+use project::{Project, Worktree};
+use prompt_store::{ProjectContext, PromptBuilder, RulesFileContext, WorktreeContext};
 use serde::{Deserialize, Serialize};
 use settings::{Settings as _, SettingsStore};
 use util::ResultExt as _;
 
 use crate::thread::{
-    DetailedSummaryState, MessageId, ProjectSnapshot, Thread, ThreadEvent, ThreadId,
+    DetailedSummaryState, ExceededWindowError, MessageId, ProjectSnapshot, Thread, ThreadId,
 };
 
+const RULES_FILE_NAMES: [&'static str; 6] = [
+    ".rules",
+    ".cursorrules",
+    ".windsurfrules",
+    ".clinerules",
+    ".github/copilot-instructions.md",
+    "CLAUDE.md",
+];
+
 pub fn init(cx: &mut App) {
     ThreadsDatabase::init(cx);
 }
 
+/// A system prompt shared by all threads created by this ThreadStore
+#[derive(Clone, Default)]
+pub struct SharedProjectContext(Rc<RefCell<Option<ProjectContext>>>);
+
+impl SharedProjectContext {
+    pub fn borrow(&self) -> Ref<Option<ProjectContext>> {
+        self.0.borrow()
+    }
+}
+
 pub struct ThreadStore {
     project: Entity<Project>,
     tools: Arc<ToolWorkingSet>,
@@ -39,43 +61,187 @@ pub struct ThreadStore {
     context_server_manager: Entity<ContextServerManager>,
     context_server_tool_ids: HashMap<Arc<str>, Vec<ToolId>>,
     threads: Vec<SerializedThreadMetadata>,
+    project_context: SharedProjectContext,
     _subscriptions: Vec<Subscription>,
 }
 
+pub struct RulesLoadingError {
+    pub message: SharedString,
+}
+
+impl EventEmitter<RulesLoadingError> for ThreadStore {}
+
 impl ThreadStore {
-    pub fn new(
+    pub fn load(
         project: Entity<Project>,
         tools: Arc<ToolWorkingSet>,
         prompt_builder: Arc<PromptBuilder>,
         cx: &mut App,
-    ) -> Result<Entity<Self>> {
-        let this = cx.new(|cx| {
-            let context_server_factory_registry = ContextServerFactoryRegistry::default_global(cx);
-            let context_server_manager = cx.new(|cx| {
-                ContextServerManager::new(context_server_factory_registry, project.clone(), cx)
-            });
-            let settings_subscription =
-                cx.observe_global::<SettingsStore>(move |this: &mut Self, cx| {
-                    this.load_default_profile(cx);
-                });
+    ) -> Task<Entity<Self>> {
+        let thread_store = cx.new(|cx| Self::new(project, tools, prompt_builder, cx));
+        let reload = thread_store.update(cx, |store, cx| store.reload_system_prompt(cx));
+        cx.foreground_executor().spawn(async move {
+            reload.await;
+            thread_store
+        })
+    }
 
-            let this = Self {
-                project,
-                tools,
-                prompt_builder,
-                context_server_manager,
-                context_server_tool_ids: HashMap::default(),
-                threads: Vec::new(),
-                _subscriptions: vec![settings_subscription],
-            };
-            this.load_default_profile(cx);
-            this.register_context_server_handlers(cx);
-            this.reload(cx).detach_and_log_err(cx);
-
-            this
+    fn new(
+        project: Entity<Project>,
+        tools: Arc<ToolWorkingSet>,
+        prompt_builder: Arc<PromptBuilder>,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let context_server_factory_registry = ContextServerFactoryRegistry::default_global(cx);
+        let context_server_manager = cx.new(|cx| {
+            ContextServerManager::new(context_server_factory_registry, project.clone(), cx)
         });
+        let settings_subscription =
+            cx.observe_global::<SettingsStore>(move |this: &mut Self, cx| {
+                this.load_default_profile(cx);
+            });
+        let project_subscription = cx.subscribe(&project, Self::handle_project_event);
 
-        Ok(this)
+        let this = Self {
+            project,
+            tools,
+            prompt_builder,
+            context_server_manager,
+            context_server_tool_ids: HashMap::default(),
+            threads: Vec::new(),
+            project_context: SharedProjectContext::default(),
+            _subscriptions: vec![settings_subscription, project_subscription],
+        };
+        this.load_default_profile(cx);
+        this.register_context_server_handlers(cx);
+        this.reload(cx).detach_and_log_err(cx);
+        this
+    }
+
+    fn handle_project_event(
+        &mut self,
+        _project: Entity<Project>,
+        event: &project::Event,
+        cx: &mut Context<Self>,
+    ) {
+        match event {
+            project::Event::WorktreeAdded(_) | project::Event::WorktreeRemoved(_) => {
+                self.reload_system_prompt(cx).detach();
+            }
+            project::Event::WorktreeUpdatedEntries(_, items) => {
+                if items.iter().any(|(path, _, _)| {
+                    RULES_FILE_NAMES
+                        .iter()
+                        .any(|name| path.as_ref() == Path::new(name))
+                }) {
+                    self.reload_system_prompt(cx).detach();
+                }
+            }
+            _ => {}
+        }
+    }
+
+    pub fn reload_system_prompt(&self, cx: &mut Context<Self>) -> Task<()> {
+        let project = self.project.read(cx);
+        let tasks = project
+            .visible_worktrees(cx)
+            .map(|worktree| {
+                Self::load_worktree_info_for_system_prompt(
+                    project.fs().clone(),
+                    worktree.read(cx),
+                    cx,
+                )
+            })
+            .collect::<Vec<_>>();
+
+        cx.spawn(async move |this, cx| {
+            let results = futures::future::join_all(tasks).await;
+            let worktrees = results
+                .into_iter()
+                .map(|(worktree, rules_error)| {
+                    if let Some(rules_error) = rules_error {
+                        this.update(cx, |_, cx| cx.emit(rules_error)).ok();
+                    }
+                    worktree
+                })
+                .collect::<Vec<_>>();
+            this.update(cx, |this, _cx| {
+                *this.project_context.0.borrow_mut() = Some(ProjectContext::new(worktrees));
+            })
+            .ok();
+        })
+    }
+
+    fn load_worktree_info_for_system_prompt(
+        fs: Arc<dyn Fs>,
+        worktree: &Worktree,
+        cx: &App,
+    ) -> Task<(WorktreeContext, Option<RulesLoadingError>)> {
+        let root_name = worktree.root_name().into();
+        let abs_path = worktree.abs_path();
+
+        let rules_task = Self::load_worktree_rules_file(fs, worktree, cx);
+        let Some(rules_task) = rules_task else {
+            return Task::ready((
+                WorktreeContext {
+                    root_name,
+                    abs_path,
+                    rules_file: None,
+                },
+                None,
+            ));
+        };
+
+        cx.spawn(async move |_| {
+            let (rules_file, rules_file_error) = match rules_task.await {
+                Ok(rules_file) => (Some(rules_file), None),
+                Err(err) => (
+                    None,
+                    Some(RulesLoadingError {
+                        message: format!("{err}").into(),
+                    }),
+                ),
+            };
+            let worktree_info = WorktreeContext {
+                root_name,
+                abs_path,
+                rules_file,
+            };
+            (worktree_info, rules_file_error)
+        })
+    }
+
+    fn load_worktree_rules_file(
+        fs: Arc<dyn Fs>,
+        worktree: &Worktree,
+        cx: &App,
+    ) -> Option<Task<Result<RulesFileContext>>> {
+        let selected_rules_file = RULES_FILE_NAMES
+            .into_iter()
+            .filter_map(|name| {
+                worktree
+                    .entry_for_path(name)
+                    .filter(|entry| entry.is_file())
+                    .map(|entry| (entry.path.clone(), worktree.absolutize(&entry.path)))
+            })
+            .next();
+
+        // Note that Cline supports `.clinerules` being a directory, but that is not currently
+        // supported. This doesn't seem to occur often in GitHub repositories.
+        selected_rules_file.map(|(path_in_worktree, abs_path)| {
+            let fs = fs.clone();
+            cx.background_spawn(async move {
+                let abs_path = abs_path?;
+                let text = fs.load(&abs_path).await.with_context(|| {
+                    format!("Failed to load assistant rules file {:?}", abs_path)
+                })?;
+                anyhow::Ok(RulesFileContext {
+                    path_in_worktree,
+                    abs_path: abs_path.into(),
+                    text: text.trim().to_string(),
+                })
+            })
+        })
     }
 
     pub fn context_server_manager(&self) -> Entity<ContextServerManager> {
@@ -107,6 +273,7 @@ impl ThreadStore {
                 self.project.clone(),
                 self.tools.clone(),
                 self.prompt_builder.clone(),
+                self.project_context.clone(),
                 cx,
             )
         })
@@ -134,21 +301,12 @@ impl ThreadStore {
                         this.project.clone(),
                         this.tools.clone(),
                         this.prompt_builder.clone(),
+                        this.project_context.clone(),
                         cx,
                     )
                 })
             })?;
 
-            let (system_prompt_context, load_error) = thread
-                .update(cx, |thread, cx| thread.load_system_prompt_context(cx))?
-                .await;
-            thread.update(cx, |thread, cx| {
-                thread.set_system_prompt_context(system_prompt_context);
-                if let Some(load_error) = load_error {
-                    cx.emit(ThreadEvent::ShowError(load_error));
-                }
-            })?;
-
             Ok(thread)
         })
     }
@@ -174,8 +332,9 @@ impl ThreadStore {
             let database = database_future.await.map_err(|err| anyhow!(err))?;
             database.delete_thread(id.clone()).await?;
 
-            this.update(cx, |this, _cx| {
-                this.threads.retain(|thread| thread.id != id)
+            this.update(cx, |this, cx| {
+                this.threads.retain(|thread| thread.id != id);
+                cx.notify();
             })
         })
     }
@@ -334,6 +493,8 @@ pub struct SerializedThread {
     pub cumulative_token_usage: TokenUsage,
     #[serde(default)]
     pub detailed_summary_state: DetailedSummaryState,
+    #[serde(default)]
+    pub exceeded_window_error: Option<ExceededWindowError>,
 }
 
 impl SerializedThread {
@@ -374,6 +535,8 @@ pub struct SerializedMessage {
     pub tool_uses: Vec<SerializedToolUse>,
     #[serde(default)]
     pub tool_results: Vec<SerializedToolResult>,
+    #[serde(default)]
+    pub context: String,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -418,6 +581,7 @@ impl LegacySerializedThread {
             initial_project_snapshot: self.initial_project_snapshot,
             cumulative_token_usage: TokenUsage::default(),
             detailed_summary_state: DetailedSummaryState::default(),
+            exceeded_window_error: None,
         }
     }
 }
@@ -441,6 +605,7 @@ impl LegacySerializedMessage {
             segments: vec![SerializedMessageSegment::Text { text: self.text }],
             tool_uses: self.tool_uses,
             tool_results: self.tool_results,
+            context: String::new(),
         }
     }
 }
@@ -487,7 +652,7 @@ impl ThreadsDatabase {
         let database_future = executor
             .spawn({
                 let executor = executor.clone();
-                let database_path = paths::support_dir().join("threads/threads-db.1.mdb");
+                let database_path = paths::data_dir().join("threads/threads-db.1.mdb");
                 async move { ThreadsDatabase::new(database_path, executor) }
             })
             .then(|result| future::ready(result.map(Arc::new).map_err(Arc::new)))

crates/agent/src/tool_use.rs

@@ -7,10 +7,11 @@ use futures::FutureExt as _;
 use futures::future::Shared;
 use gpui::{App, SharedString, Task};
 use language_model::{
-    LanguageModelRequestMessage, LanguageModelToolResult, LanguageModelToolUse,
-    LanguageModelToolUseId, MessageContent, Role,
+    LanguageModelRegistry, LanguageModelRequestMessage, LanguageModelToolResult,
+    LanguageModelToolUse, LanguageModelToolUseId, MessageContent, Role,
 };
 use ui::IconName;
+use util::truncate_lines_to_byte_limit;
 
 use crate::thread::MessageId;
 use crate::thread_store::SerializedMessage;
@@ -35,6 +36,18 @@ pub enum ToolUseStatus {
     Error(SharedString),
 }
 
+impl ToolUseStatus {
+    pub fn text(&self) -> SharedString {
+        match self {
+            ToolUseStatus::NeedsConfirmation => "".into(),
+            ToolUseStatus::Pending => "".into(),
+            ToolUseStatus::Running => "".into(),
+            ToolUseStatus::Finished(out) => out.clone(),
+            ToolUseStatus::Error(out) => out.clone(),
+        }
+    }
+}
+
 pub struct ToolUseState {
     tools: Arc<ToolWorkingSet>,
     tool_uses_by_assistant_message: HashMap<MessageId, Vec<LanguageModelToolUse>>,
@@ -43,6 +56,8 @@ pub struct ToolUseState {
     pending_tool_uses_by_id: HashMap<LanguageModelToolUseId, PendingToolUse>,
 }
 
+pub const USING_TOOL_MARKER: &str = "<using_tool>";
+
 impl ToolUseState {
     pub fn new(tools: Arc<ToolWorkingSet>) -> Self {
         Self {
@@ -186,7 +201,7 @@ impl ToolUseState {
 
             let (icon, needs_confirmation) = if let Some(tool) = self.tools.tool(&tool_use.name, cx)
             {
-                (tool.icon(), tool.needs_confirmation())
+                (tool.icon(), tool.needs_confirmation(&tool_use.input, cx))
             } else {
                 (IconName::Cog, false)
             };
@@ -317,9 +332,34 @@ impl ToolUseState {
         tool_use_id: LanguageModelToolUseId,
         tool_name: Arc<str>,
         output: Result<String>,
+        cx: &App,
     ) -> Option<PendingToolUse> {
+        telemetry::event!("Agent Tool Finished", tool_name, success = output.is_ok());
+
         match output {
             Ok(tool_result) => {
+                let model_registry = LanguageModelRegistry::read_global(cx);
+
+                const BYTES_PER_TOKEN_ESTIMATE: usize = 3;
+
+                // Protect from clearly large output
+                let tool_output_limit = model_registry
+                    .default_model()
+                    .map(|model| model.model.max_token_count() * BYTES_PER_TOKEN_ESTIMATE)
+                    .unwrap_or(usize::MAX);
+
+                let tool_result = if tool_result.len() <= tool_output_limit {
+                    tool_result
+                } else {
+                    let truncated = truncate_lines_to_byte_limit(&tool_result, tool_output_limit);
+
+                    format!(
+                        "Tool result too long. The first {} bytes:\n\n{}",
+                        truncated.len(),
+                        truncated
+                    )
+                };
+
                 self.tool_results.insert(
                     tool_use_id.clone(),
                     LanguageModelToolResult {
@@ -357,8 +397,28 @@ impl ToolUseState {
         request_message: &mut LanguageModelRequestMessage,
     ) {
         if let Some(tool_uses) = self.tool_uses_by_assistant_message.get(&message_id) {
+            let mut found_tool_use = false;
+
             for tool_use in tool_uses {
                 if self.tool_results.contains_key(&tool_use.id) {
+                    if !found_tool_use {
+                        // The API fails if a message contains a tool use without any (non-whitespace) text around it
+                        match request_message.content.last_mut() {
+                            Some(MessageContent::Text(txt)) => {
+                                if txt.is_empty() {
+                                    txt.push_str(USING_TOOL_MARKER);
+                                }
+                            }
+                            None | Some(_) => {
+                                request_message
+                                    .content
+                                    .push(MessageContent::Text(USING_TOOL_MARKER.into()));
+                            }
+                        };
+                    }
+
+                    found_tool_use = true;
+
                     // Do not send tool uses until they are completed
                     request_message
                         .content

crates/agent/src/ui.rs

@@ -1,5 +1,7 @@
 mod agent_notification;
 mod context_pill;
+mod user_spending;
 
 pub use agent_notification::*;
 pub use context_pill::*;
+// pub use user_spending::*;

crates/agent/src/ui/context_pill.rs

@@ -280,9 +280,10 @@ impl AddedContext {
             }
 
             AssistantContext::Directory(directory_context) => {
-                // TODO: handle worktree disambiguation. Maybe by storing an `Arc<dyn File>` to also
-                // handle renames?
-                let full_path = &directory_context.project_path.path;
+                let full_path = directory_context
+                    .worktree
+                    .read(cx)
+                    .full_path(&directory_context.path);
                 let full_path_string: SharedString =
                     full_path.to_string_lossy().into_owned().into();
                 let name = full_path

crates/agent/src/ui/user_spending.rs

@@ -0,0 +1,186 @@
+use gpui::{Entity, Render};
+use ui::{ProgressBar, prelude::*};
+
+#[derive(RegisterComponent)]
+pub struct UserSpending {
+    free_tier_current: u32,
+    free_tier_cap: u32,
+    over_tier_current: u32,
+    over_tier_cap: u32,
+    free_tier_progress: Entity<ProgressBar>,
+    over_tier_progress: Entity<ProgressBar>,
+}
+
+impl UserSpending {
+    pub fn new(
+        free_tier_current: u32,
+        free_tier_cap: u32,
+        over_tier_current: u32,
+        over_tier_cap: u32,
+        cx: &mut App,
+    ) -> Self {
+        let free_tier_capped = free_tier_current == free_tier_cap;
+        let free_tier_near_capped =
+            free_tier_current as f32 / 100.0 >= free_tier_cap as f32 / 100.0 * 0.9;
+        let over_tier_capped = over_tier_current == over_tier_cap;
+        let over_tier_near_capped =
+            over_tier_current as f32 / 100.0 >= over_tier_cap as f32 / 100.0 * 0.9;
+
+        let free_tier_progress = cx.new(|cx| {
+            ProgressBar::new(
+                "free_tier",
+                free_tier_current as f32,
+                free_tier_cap as f32,
+                cx,
+            )
+        });
+        let over_tier_progress = cx.new(|cx| {
+            ProgressBar::new(
+                "over_tier",
+                over_tier_current as f32,
+                over_tier_cap as f32,
+                cx,
+            )
+        });
+
+        if free_tier_capped {
+            free_tier_progress.update(cx, |progress_bar, cx| {
+                progress_bar.fg_color(cx.theme().status().error);
+            });
+        } else if free_tier_near_capped {
+            free_tier_progress.update(cx, |progress_bar, cx| {
+                progress_bar.fg_color(cx.theme().status().warning);
+            });
+        }
+
+        if over_tier_capped {
+            over_tier_progress.update(cx, |progress_bar, cx| {
+                progress_bar.fg_color(cx.theme().status().error);
+            });
+        } else if over_tier_near_capped {
+            over_tier_progress.update(cx, |progress_bar, cx| {
+                progress_bar.fg_color(cx.theme().status().warning);
+            });
+        }
+
+        Self {
+            free_tier_current,
+            free_tier_cap,
+            over_tier_current,
+            over_tier_cap,
+            free_tier_progress,
+            over_tier_progress,
+        }
+    }
+}
+
+impl Render for UserSpending {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let formatted_free_tier = format!(
+            "${} / ${}",
+            self.free_tier_current as f32 / 100.0,
+            self.free_tier_cap as f32 / 100.0
+        );
+        let formatted_over_tier = format!(
+            "${} / ${}",
+            self.over_tier_current as f32 / 100.0,
+            self.over_tier_cap as f32 / 100.0
+        );
+
+        v_group()
+            .elevation_2(cx)
+            .py_1p5()
+            .px_2p5()
+            .w(px(360.))
+            .child(
+                v_flex()
+                    .child(
+                        v_flex()
+                            .p_1p5()
+                            .gap_0p5()
+                            .child(
+                                h_flex()
+                                    .justify_between()
+                                    .child(Label::new("Free Tier Usage").size(LabelSize::Small))
+                                    .child(
+                                        Label::new(formatted_free_tier)
+                                            .size(LabelSize::Small)
+                                            .color(Color::Muted),
+                                    ),
+                            )
+                            .child(self.free_tier_progress.clone()),
+                    )
+                    .child(
+                        v_flex()
+                            .p_1p5()
+                            .gap_0p5()
+                            .child(
+                                h_flex()
+                                    .justify_between()
+                                    .child(Label::new("Current Spending").size(LabelSize::Small))
+                                    .child(
+                                        Label::new(formatted_over_tier)
+                                            .size(LabelSize::Small)
+                                            .color(Color::Muted),
+                                    ),
+                            )
+                            .child(self.over_tier_progress.clone()),
+                    ),
+            )
+    }
+}
+
+impl Component for UserSpending {
+    fn scope() -> ComponentScope {
+        ComponentScope::None
+    }
+
+    fn preview(_window: &mut Window, cx: &mut App) -> Option<AnyElement> {
+        let new_user = cx.new(|cx| UserSpending::new(0, 2000, 0, 2000, cx));
+        let free_capped = cx.new(|cx| UserSpending::new(2000, 2000, 0, 2000, cx));
+        let free_near_capped = cx.new(|cx| UserSpending::new(1800, 2000, 0, 2000, cx));
+        let over_near_capped = cx.new(|cx| UserSpending::new(2000, 2000, 1800, 2000, cx));
+        let over_capped = cx.new(|cx| UserSpending::new(1000, 2000, 2000, 2000, cx));
+
+        Some(
+            v_flex()
+                .gap_6()
+                .p_4()
+                .children(vec![example_group(vec![
+                    single_example(
+                        "New User",
+                        div().size_full().child(new_user.clone()).into_any_element(),
+                    ),
+                    single_example(
+                        "Free Tier Capped",
+                        div()
+                            .size_full()
+                            .child(free_capped.clone())
+                            .into_any_element(),
+                    ),
+                    single_example(
+                        "Free Tier Near Capped",
+                        div()
+                            .size_full()
+                            .child(free_near_capped.clone())
+                            .into_any_element(),
+                    ),
+                    single_example(
+                        "Over Tier Near Capped",
+                        div()
+                            .size_full()
+                            .child(over_near_capped.clone())
+                            .into_any_element(),
+                    ),
+                    single_example(
+                        "Over Tier Capped",
+                        div()
+                            .size_full()
+                            .child(over_capped.clone())
+                            .into_any_element(),
+                    ),
+                ])])
+                .into_any_element(),
+        )
+    }
+}

crates/anthropic/Cargo.toml

@@ -26,3 +26,4 @@ serde_json.workspace = true
 strum.workspace = true
 thiserror.workspace = true
 util.workspace = true
+workspace-hack.workspace = true

crates/anthropic/src/anthropic.rs

@@ -1,10 +1,10 @@
 mod supported_countries;
 
-use std::{pin::Pin, str::FromStr};
+use std::str::FromStr;
 
 use anyhow::{Context as _, Result, anyhow};
 use chrono::{DateTime, Utc};
-use futures::{AsyncBufReadExt, AsyncReadExt, Stream, StreamExt, io::BufReader, stream::BoxStream};
+use futures::{AsyncBufReadExt, AsyncReadExt, StreamExt, io::BufReader, stream::BoxStream};
 use http_client::http::{HeaderMap, HeaderValue};
 use http_client::{AsyncBody, HttpClient, Method, Request as HttpRequest};
 use serde::{Deserialize, Serialize};
@@ -37,9 +37,9 @@ pub enum AnthropicModelMode {
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, EnumIter)]
 pub enum Model {
-    #[default]
     #[serde(rename = "claude-3-5-sonnet", alias = "claude-3-5-sonnet-latest")]
     Claude3_5Sonnet,
+    #[default]
     #[serde(rename = "claude-3-7-sonnet", alias = "claude-3-7-sonnet-latest")]
     Claude3_7Sonnet,
     #[serde(
@@ -220,16 +220,23 @@ impl Model {
             .map(|header| header.to_string())
             .collect::<Vec<_>>();
 
-        if let Self::Custom {
-            extra_beta_headers, ..
-        } = self
-        {
-            headers.extend(
-                extra_beta_headers
-                    .iter()
-                    .filter(|header| !header.trim().is_empty())
-                    .cloned(),
-            );
+        match self {
+            Self::Claude3_7Sonnet | Self::Claude3_7SonnetThinking => {
+                // Try beta token-efficient tool use (supported in Claude 3.7 Sonnet only)
+                // https://docs.anthropic.com/en/docs/build-with-claude/tool-use/token-efficient-tool-use
+                headers.push("token-efficient-tools-2025-02-19".to_string());
+            }
+            Self::Custom {
+                extra_beta_headers, ..
+            } => {
+                headers.extend(
+                    extra_beta_headers
+                        .iter()
+                        .filter(|header| !header.trim().is_empty())
+                        .cloned(),
+                );
+            }
+            _ => {}
         }
 
         headers.join(",")
@@ -314,38 +321,54 @@ pub async fn stream_completion(
         .map(|output| output.0)
 }
 
+/// An individual rate limit.
+#[derive(Debug)]
+pub struct RateLimit {
+    pub limit: usize,
+    pub remaining: usize,
+    pub reset: DateTime<Utc>,
+}
+
+impl RateLimit {
+    fn from_headers(resource: &str, headers: &HeaderMap<HeaderValue>) -> Result<Self> {
+        let limit =
+            get_header(&format!("anthropic-ratelimit-{resource}-limit"), headers)?.parse()?;
+        let remaining = get_header(
+            &format!("anthropic-ratelimit-{resource}-remaining"),
+            headers,
+        )?
+        .parse()?;
+        let reset = DateTime::parse_from_rfc3339(get_header(
+            &format!("anthropic-ratelimit-{resource}-reset"),
+            headers,
+        )?)?
+        .to_utc();
+
+        Ok(Self {
+            limit,
+            remaining,
+            reset,
+        })
+    }
+}
+
 /// <https://docs.anthropic.com/en/api/rate-limits#response-headers>
 #[derive(Debug)]
 pub struct RateLimitInfo {
-    pub requests_limit: usize,
-    pub requests_remaining: usize,
-    pub requests_reset: DateTime<Utc>,
-    pub tokens_limit: usize,
-    pub tokens_remaining: usize,
-    pub tokens_reset: DateTime<Utc>,
+    pub requests: Option<RateLimit>,
+    pub tokens: Option<RateLimit>,
+    pub input_tokens: Option<RateLimit>,
+    pub output_tokens: Option<RateLimit>,
 }
 
 impl RateLimitInfo {
-    fn from_headers(headers: &HeaderMap<HeaderValue>) -> Result<Self> {
-        let tokens_limit = get_header("anthropic-ratelimit-tokens-limit", headers)?.parse()?;
-        let requests_limit = get_header("anthropic-ratelimit-requests-limit", headers)?.parse()?;
-        let tokens_remaining =
-            get_header("anthropic-ratelimit-tokens-remaining", headers)?.parse()?;
-        let requests_remaining =
-            get_header("anthropic-ratelimit-requests-remaining", headers)?.parse()?;
-        let requests_reset = get_header("anthropic-ratelimit-requests-reset", headers)?;
-        let tokens_reset = get_header("anthropic-ratelimit-tokens-reset", headers)?;
-        let requests_reset = DateTime::parse_from_rfc3339(requests_reset)?.to_utc();
-        let tokens_reset = DateTime::parse_from_rfc3339(tokens_reset)?.to_utc();
-
-        Ok(Self {
-            requests_limit,
-            tokens_limit,
-            requests_remaining,
-            tokens_remaining,
-            requests_reset,
-            tokens_reset,
-        })
+    fn from_headers(headers: &HeaderMap<HeaderValue>) -> Self {
+        Self {
+            requests: RateLimit::from_headers("requests", headers).log_err(),
+            tokens: RateLimit::from_headers("tokens", headers).log_err(),
+            input_tokens: RateLimit::from_headers("input-tokens", headers).log_err(),
+            output_tokens: RateLimit::from_headers("output-tokens", headers).log_err(),
+        }
     }
 }
 
@@ -411,7 +434,7 @@ pub async fn stream_completion_with_rate_limit_info(
                 }
             })
             .boxed();
-        Ok((stream, rate_limits.log_err()))
+        Ok((stream, Some(rate_limits)))
     } else {
         let mut body = Vec::new();
         response
@@ -437,50 +460,6 @@ pub async fn stream_completion_with_rate_limit_info(
     }
 }
 
-pub async fn extract_tool_args_from_events(
-    tool_name: String,
-    mut events: Pin<Box<dyn Send + Stream<Item = Result<Event>>>>,
-) -> Result<impl Send + Stream<Item = Result<String>>> {
-    let mut tool_use_index = None;
-    while let Some(event) = events.next().await {
-        if let Event::ContentBlockStart {
-            index,
-            content_block: ResponseContent::ToolUse { name, .. },
-        } = event?
-        {
-            if name == tool_name {
-                tool_use_index = Some(index);
-                break;
-            }
-        }
-    }
-
-    let Some(tool_use_index) = tool_use_index else {
-        return Err(anyhow!("tool not used"));
-    };
-
-    Ok(events.filter_map(move |event| {
-        let result = match event {
-            Err(error) => Some(Err(error)),
-            Ok(Event::ContentBlockDelta { index, delta }) => match delta {
-                ContentDelta::TextDelta { .. } => None,
-                ContentDelta::ThinkingDelta { .. } => None,
-                ContentDelta::SignatureDelta { .. } => None,
-                ContentDelta::InputJsonDelta { partial_json } => {
-                    if index == tool_use_index {
-                        Some(Ok(partial_json))
-                    } else {
-                        None
-                    }
-                }
-            },
-            _ => None,
-        };
-
-        async move { result }
-    }))
-}
-
 #[derive(Debug, Serialize, Deserialize, Copy, Clone)]
 #[serde(rename_all = "lowercase")]
 pub enum CacheControlType {
@@ -745,4 +724,54 @@ impl ApiError {
     pub fn is_rate_limit_error(&self) -> bool {
         matches!(self.error_type.as_str(), "rate_limit_error")
     }
+
+    pub fn match_window_exceeded(&self) -> Option<usize> {
+        let Some(ApiErrorCode::InvalidRequestError) = self.code() else {
+            return None;
+        };
+
+        parse_prompt_too_long(&self.message)
+    }
+}
+
+pub fn parse_prompt_too_long(message: &str) -> Option<usize> {
+    message
+        .strip_prefix("prompt is too long: ")?
+        .split_once(" tokens")?
+        .0
+        .parse::<usize>()
+        .ok()
+}
+
+#[test]
+fn test_match_window_exceeded() {
+    let error = ApiError {
+        error_type: "invalid_request_error".to_string(),
+        message: "prompt is too long: 220000 tokens > 200000".to_string(),
+    };
+    assert_eq!(error.match_window_exceeded(), Some(220_000));
+
+    let error = ApiError {
+        error_type: "invalid_request_error".to_string(),
+        message: "prompt is too long: 1234953 tokens".to_string(),
+    };
+    assert_eq!(error.match_window_exceeded(), Some(1234953));
+
+    let error = ApiError {
+        error_type: "invalid_request_error".to_string(),
+        message: "not a prompt length error".to_string(),
+    };
+    assert_eq!(error.match_window_exceeded(), None);
+
+    let error = ApiError {
+        error_type: "rate_limit_error".to_string(),
+        message: "prompt is too long: 12345 tokens".to_string(),
+    };
+    assert_eq!(error.match_window_exceeded(), None);
+
+    let error = ApiError {
+        error_type: "invalid_request_error".to_string(),
+        message: "prompt is too long: invalid tokens".to_string(),
+    };
+    assert_eq!(error.match_window_exceeded(), None);
 }

crates/askpass/Cargo.toml

@@ -19,3 +19,4 @@ smol.workspace = true
 tempfile.workspace = true
 util.workspace = true
 which.workspace = true
+workspace-hack.workspace = true

crates/assets/Cargo.toml

@@ -15,3 +15,4 @@ workspace = true
 anyhow.workspace = true
 gpui.workspace = true
 rust-embed.workspace = true
+workspace-hack.workspace = true

crates/assistant/Cargo.toml

@@ -69,6 +69,7 @@ ui.workspace = true
 util.workspace = true
 workspace.workspace = true
 zed_actions.workspace = true
+workspace-hack.workspace = true
 
 [dev-dependencies]
 ctor.workspace = true

crates/assistant/src/assistant.rs

@@ -161,12 +161,38 @@ fn init_language_model_settings(cx: &mut App) {
 
 fn update_active_language_model_from_settings(cx: &mut App) {
     let settings = AssistantSettings::get_global(cx);
+    // Default model - used as fallback
     let active_model_provider_name =
         LanguageModelProviderId::from(settings.default_model.provider.clone());
     let active_model_id = LanguageModelId::from(settings.default_model.model.clone());
-    let editor_provider_name =
-        LanguageModelProviderId::from(settings.editor_model.provider.clone());
-    let editor_model_id = LanguageModelId::from(settings.editor_model.model.clone());
+
+    // Inline assistant model
+    let inline_assistant_model = settings
+        .inline_assistant_model
+        .as_ref()
+        .unwrap_or(&settings.default_model);
+    let inline_assistant_provider_name =
+        LanguageModelProviderId::from(inline_assistant_model.provider.clone());
+    let inline_assistant_model_id = LanguageModelId::from(inline_assistant_model.model.clone());
+
+    // Commit message model
+    let commit_message_model = settings
+        .commit_message_model
+        .as_ref()
+        .unwrap_or(&settings.default_model);
+    let commit_message_provider_name =
+        LanguageModelProviderId::from(commit_message_model.provider.clone());
+    let commit_message_model_id = LanguageModelId::from(commit_message_model.model.clone());
+
+    // Thread summary model
+    let thread_summary_model = settings
+        .thread_summary_model
+        .as_ref()
+        .unwrap_or(&settings.default_model);
+    let thread_summary_provider_name =
+        LanguageModelProviderId::from(thread_summary_model.provider.clone());
+    let thread_summary_model_id = LanguageModelId::from(thread_summary_model.model.clone());
+
     let inline_alternatives = settings
         .inline_alternatives
         .iter()
@@ -177,9 +203,29 @@ fn update_active_language_model_from_settings(cx: &mut App) {
             )
         })
         .collect::<Vec<_>>();
+
     LanguageModelRegistry::global(cx).update(cx, |registry, cx| {
-        registry.select_active_model(&active_model_provider_name, &active_model_id, cx);
-        registry.select_editor_model(&editor_provider_name, &editor_model_id, cx);
+        // Set the default model
+        registry.select_default_model(&active_model_provider_name, &active_model_id, cx);
+
+        // Set the specific models
+        registry.select_inline_assistant_model(
+            &inline_assistant_provider_name,
+            &inline_assistant_model_id,
+            cx,
+        );
+        registry.select_commit_message_model(
+            &commit_message_provider_name,
+            &commit_message_model_id,
+            cx,
+        );
+        registry.select_thread_summary_model(
+            &thread_summary_provider_name,
+            &thread_summary_model_id,
+            cx,
+        );
+
+        // Set the alternatives
         registry.select_inline_alternative_models(inline_alternatives, cx);
     });
 }

crates/assistant/src/assistant_panel.rs

@@ -22,7 +22,8 @@ use gpui::{
 };
 use language::LanguageRegistry;
 use language_model::{
-    AuthenticateError, LanguageModelProviderId, LanguageModelRegistry, ZED_CLOUD_PROVIDER_ID,
+    AuthenticateError, ConfiguredModel, LanguageModelProviderId, LanguageModelRegistry,
+    ZED_CLOUD_PROVIDER_ID,
 };
 use project::Project;
 use prompt_library::{PromptLibrary, open_prompt_library};
@@ -36,11 +37,11 @@ use ui::{ContextMenu, PopoverMenu, Tooltip, prelude::*};
 use util::{ResultExt, maybe};
 use workspace::DraggedTab;
 use workspace::{
-    DraggedSelection, Pane, ShowConfiguration, ToggleZoom, Workspace,
+    DraggedSelection, Pane, ToggleZoom, Workspace,
     dock::{DockPosition, Panel, PanelEvent},
     pane,
 };
-use zed_actions::assistant::{InlineAssist, OpenPromptLibrary, ToggleFocus};
+use zed_actions::assistant::{InlineAssist, OpenPromptLibrary, ShowConfiguration, ToggleFocus};
 
 pub fn init(cx: &mut App) {
     workspace::FollowableViewRegistry::register::<ContextEditor>(cx);
@@ -53,7 +54,15 @@ pub fn init(cx: &mut App) {
                 .register_action(ContextEditor::insert_dragged_files)
                 .register_action(AssistantPanel::show_configuration)
                 .register_action(AssistantPanel::create_new_context)
-                .register_action(AssistantPanel::restart_context_servers);
+                .register_action(AssistantPanel::restart_context_servers)
+                .register_action(|workspace, _: &OpenPromptLibrary, window, cx| {
+                    if let Some(panel) = workspace.panel::<AssistantPanel>(cx) {
+                        workspace.focus_panel::<AssistantPanel>(window, cx);
+                        panel.update(cx, |panel, cx| {
+                            panel.deploy_prompt_library(&OpenPromptLibrary, window, cx)
+                        });
+                    }
+                });
         },
     )
     .detach();
@@ -298,8 +307,10 @@ impl AssistantPanel {
                 &LanguageModelRegistry::global(cx),
                 window,
                 |this, _, event: &language_model::Event, window, cx| match event {
-                    language_model::Event::ActiveModelChanged
-                    | language_model::Event::EditorModelChanged => {
+                    language_model::Event::DefaultModelChanged
+                    | language_model::Event::InlineAssistantModelChanged
+                    | language_model::Event::CommitMessageModelChanged
+                    | language_model::Event::ThreadSummaryModelChanged => {
                         this.completion_provider_changed(window, cx);
                     }
                     language_model::Event::ProviderStateChanged => {
@@ -468,12 +479,12 @@ impl AssistantPanel {
     }
 
     fn update_zed_ai_notice_visibility(&mut self, client_status: Status, cx: &mut Context<Self>) {
-        let active_provider = LanguageModelRegistry::read_global(cx).active_provider();
+        let model = LanguageModelRegistry::read_global(cx).default_model();
 
         // If we're signed out and don't have a provider configured, or we're signed-out AND Zed.dev is
         // the provider, we want to show a nudge to sign in.
         let show_zed_ai_notice = client_status.is_signed_out()
-            && active_provider.map_or(true, |provider| provider.id().0 == ZED_CLOUD_PROVIDER_ID);
+            && model.map_or(true, |model| model.provider.id().0 == ZED_CLOUD_PROVIDER_ID);
 
         self.show_zed_ai_notice = show_zed_ai_notice;
         cx.notify();
@@ -541,8 +552,8 @@ impl AssistantPanel {
         }
 
         let Some(new_provider_id) = LanguageModelRegistry::read_global(cx)
-            .active_provider()
-            .map(|p| p.id())
+            .default_model()
+            .map(|default| default.provider.id())
         else {
             return;
         };
@@ -568,7 +579,9 @@ impl AssistantPanel {
             return;
         }
 
-        let Some(provider) = LanguageModelRegistry::read_global(cx).active_provider() else {
+        let Some(ConfiguredModel { provider, .. }) =
+            LanguageModelRegistry::read_global(cx).default_model()
+        else {
             return;
         };
 
@@ -976,8 +989,8 @@ impl AssistantPanel {
                 |this, _, event: &ConfigurationViewEvent, window, cx| match event {
                     ConfigurationViewEvent::NewProviderContextEditor(provider) => {
                         if LanguageModelRegistry::read_global(cx)
-                            .active_provider()
-                            .map_or(true, |p| p.id() != provider.id())
+                            .default_model()
+                            .map_or(true, |default| default.provider.id() != provider.id())
                         {
                             if let Some(model) = provider.default_model(cx) {
                                 update_settings_file::<AssistantSettings>(
@@ -1155,8 +1168,8 @@ impl AssistantPanel {
 
     fn is_authenticated(&mut self, cx: &mut Context<Self>) -> bool {
         LanguageModelRegistry::read_global(cx)
-            .active_provider()
-            .map_or(false, |provider| provider.is_authenticated(cx))
+            .default_model()
+            .map_or(false, |default| default.provider.is_authenticated(cx))
     }
 
     fn authenticate(
@@ -1164,8 +1177,8 @@ impl AssistantPanel {
         cx: &mut Context<Self>,
     ) -> Option<Task<Result<(), AuthenticateError>>> {
         LanguageModelRegistry::read_global(cx)
-            .active_provider()
-            .map_or(None, |provider| Some(provider.authenticate(cx)))
+            .default_model()
+            .map_or(None, |default| Some(default.provider.authenticate(cx)))
     }
 
     fn restart_context_servers(

crates/assistant/src/inline_assistant.rs

@@ -34,8 +34,8 @@ use gpui::{
 };
 use language::{Buffer, IndentKind, Point, Selection, TransactionId, line_diff};
 use language_model::{
-    LanguageModel, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage,
-    LanguageModelTextStream, Role, report_assistant_event,
+    ConfiguredModel, LanguageModel, LanguageModelRegistry, LanguageModelRequest,
+    LanguageModelRequestMessage, LanguageModelTextStream, Role, report_assistant_event,
 };
 use language_model_selector::{LanguageModelSelector, LanguageModelSelectorPopoverMenu};
 use multi_buffer::MultiBufferRow;
@@ -57,7 +57,7 @@ use std::{
     time::{Duration, Instant},
 };
 use streaming_diff::{CharOperation, LineDiff, LineOperation, StreamingDiff};
-use telemetry_events::{AssistantEvent, AssistantKind, AssistantPhase};
+use telemetry_events::{AssistantEventData, AssistantKind, AssistantPhase};
 use terminal_view::terminal_panel::TerminalPanel;
 use text::{OffsetRangeExt, ToPoint as _};
 use theme::ThemeSettings;
@@ -312,8 +312,10 @@ impl InlineAssistant {
                 start..end,
             ));
 
-            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
-                self.telemetry.report_assistant_event(AssistantEvent {
+            if let Some(ConfiguredModel { model, .. }) =
+                LanguageModelRegistry::read_global(cx).default_model()
+            {
+                self.telemetry.report_assistant_event(AssistantEventData {
                     conversation_id: None,
                     kind: AssistantKind::Inline,
                     phase: AssistantPhase::Invoked,
@@ -525,14 +527,14 @@ impl InlineAssistant {
             BlockProperties {
                 style: BlockStyle::Sticky,
                 placement: BlockPlacement::Above(range.start),
-                height: prompt_editor_height,
+                height: Some(prompt_editor_height),
                 render: build_assist_editor_renderer(prompt_editor),
                 priority: 0,
             },
             BlockProperties {
                 style: BlockStyle::Sticky,
                 placement: BlockPlacement::Below(range.end),
-                height: 0,
+                height: None,
                 render: Arc::new(|cx| {
                     v_flex()
                         .h_full()
@@ -877,7 +879,9 @@ impl InlineAssistant {
             let active_alternative = assist.codegen.read(cx).active_alternative().clone();
             let message_id = active_alternative.read(cx).message_id.clone();
 
-            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
+            if let Some(ConfiguredModel { model, .. }) =
+                LanguageModelRegistry::read_global(cx).default_model()
+            {
                 let language_name = assist.editor.upgrade().and_then(|editor| {
                     let multibuffer = editor.read(cx).buffer().read(cx);
                     let multibuffer_snapshot = multibuffer.snapshot(cx);
@@ -888,7 +892,7 @@ impl InlineAssistant {
                         .map(|language| language.name())
                 });
                 report_assistant_event(
-                    AssistantEvent {
+                    AssistantEventData {
                         conversation_id: None,
                         kind: AssistantKind::Inline,
                         message_id,
@@ -1297,7 +1301,7 @@ impl InlineAssistant {
                     deleted_lines_editor.update(cx, |editor, cx| editor.max_point(cx).row().0 + 1);
                 new_blocks.push(BlockProperties {
                     placement: BlockPlacement::Above(new_row),
-                    height,
+                    height: Some(height),
                     style: BlockStyle::Flex,
                     render: Arc::new(move |cx| {
                         div()
@@ -1629,8 +1633,8 @@ impl Render for PromptEditor {
                                 format!(
                                     "Using {}",
                                     LanguageModelRegistry::read_global(cx)
-                                        .active_model()
-                                        .map(|model| model.name().0)
+                                        .default_model()
+                                        .map(|default| default.model.name().0)
                                         .unwrap_or_else(|| "No model selected".into()),
                                 ),
                                 None,
@@ -2077,7 +2081,7 @@ impl PromptEditor {
         let disabled = matches!(codegen.status(cx), CodegenStatus::Idle);
 
         let model_registry = LanguageModelRegistry::read_global(cx);
-        let default_model = model_registry.active_model();
+        let default_model = model_registry.default_model().map(|default| default.model);
         let alternative_models = model_registry.inline_alternative_models();
 
         let get_model_name = |index: usize| -> String {
@@ -2183,7 +2187,9 @@ impl PromptEditor {
     }
 
     fn render_token_count(&self, cx: &mut Context<Self>) -> Option<impl IntoElement> {
-        let model = LanguageModelRegistry::read_global(cx).active_model()?;
+        let model = LanguageModelRegistry::read_global(cx)
+            .default_model()?
+            .model;
         let token_counts = self.token_counts?;
         let max_token_count = model.max_token_count();
 
@@ -2638,8 +2644,9 @@ impl Codegen {
         }
 
         let primary_model = LanguageModelRegistry::read_global(cx)
-            .active_model()
-            .context("no active model")?;
+            .default_model()
+            .context("no active model")?
+            .model;
 
         for (model, alternative) in iter::once(primary_model)
             .chain(alternative_models)
@@ -2863,7 +2870,9 @@ impl CodegenAlternative {
         assistant_panel_context: Option<LanguageModelRequest>,
         cx: &App,
     ) -> BoxFuture<'static, Result<TokenCounts>> {
-        if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
+        if let Some(ConfiguredModel { model, .. }) =
+            LanguageModelRegistry::read_global(cx).inline_assistant_model()
+        {
             let request = self.build_request(user_prompt, assistant_panel_context.clone(), cx);
             match request {
                 Ok(request) => {
@@ -3139,7 +3148,7 @@ impl CodegenAlternative {
 
                         let error_message = result.as_ref().err().map(|error| error.to_string());
                         report_assistant_event(
-                            AssistantEvent {
+                            AssistantEventData {
                                 conversation_id: None,
                                 message_id,
                                 kind: AssistantKind::Inline,

crates/assistant/src/terminal_inline_assistant.rs

@@ -16,8 +16,8 @@ use gpui::{
 };
 use language::Buffer;
 use language_model::{
-    LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage, Role,
-    report_assistant_event,
+    ConfiguredModel, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage,
+    Role, report_assistant_event,
 };
 use language_model_selector::{LanguageModelSelector, LanguageModelSelectorPopoverMenu};
 use prompt_store::PromptBuilder;
@@ -27,7 +27,7 @@ use std::{
     sync::Arc,
     time::{Duration, Instant},
 };
-use telemetry_events::{AssistantEvent, AssistantKind, AssistantPhase};
+use telemetry_events::{AssistantEventData, AssistantKind, AssistantPhase};
 use terminal::Terminal;
 use terminal_view::TerminalView;
 use theme::ThemeSettings;
@@ -318,11 +318,13 @@ impl TerminalInlineAssistant {
                 })
                 .log_err();
 
-            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
+            if let Some(ConfiguredModel { model, .. }) =
+                LanguageModelRegistry::read_global(cx).inline_assistant_model()
+            {
                 let codegen = assist.codegen.read(cx);
                 let executor = cx.background_executor().clone();
                 report_assistant_event(
-                    AssistantEvent {
+                    AssistantEventData {
                         conversation_id: None,
                         kind: AssistantKind::InlineTerminal,
                         message_id: codegen.message_id.clone(),
@@ -652,8 +654,8 @@ impl Render for PromptEditor {
                                 format!(
                                     "Using {}",
                                     LanguageModelRegistry::read_global(cx)
-                                        .active_model()
-                                        .map(|model| model.name().0)
+                                        .inline_assistant_model()
+                                        .map(|inline_assistant| inline_assistant.model.name().0)
                                         .unwrap_or_else(|| "No model selected".into()),
                                 ),
                                 None,
@@ -822,7 +824,9 @@ impl PromptEditor {
 
     fn count_tokens(&mut self, cx: &mut Context<Self>) {
         let assist_id = self.id;
-        let Some(model) = LanguageModelRegistry::read_global(cx).active_model() else {
+        let Some(ConfiguredModel { model, .. }) =
+            LanguageModelRegistry::read_global(cx).inline_assistant_model()
+        else {
             return;
         };
         self.pending_token_count = cx.spawn(async move |this, cx| {
@@ -980,7 +984,9 @@ impl PromptEditor {
     }
 
     fn render_token_count(&self, cx: &mut Context<Self>) -> Option<impl IntoElement> {
-        let model = LanguageModelRegistry::read_global(cx).active_model()?;
+        let model = LanguageModelRegistry::read_global(cx)
+            .inline_assistant_model()?
+            .model;
         let token_count = self.token_count?;
         let max_token_count = model.max_token_count();
 
@@ -1131,7 +1137,9 @@ impl Codegen {
     }
 
     pub fn start(&mut self, prompt: LanguageModelRequest, cx: &mut Context<Self>) {
-        let Some(model) = LanguageModelRegistry::read_global(cx).active_model() else {
+        let Some(ConfiguredModel { model, .. }) =
+            LanguageModelRegistry::read_global(cx).inline_assistant_model()
+        else {
             return;
         };
 
@@ -1175,7 +1183,7 @@ impl Codegen {
 
                         let error_message = result.as_ref().err().map(|error| error.to_string());
                         report_assistant_event(
-                            AssistantEvent {
+                            AssistantEventData {
                                 conversation_id: None,
                                 kind: AssistantKind::InlineTerminal,
                                 message_id,

crates/assistant_context_editor/Cargo.toml

@@ -22,6 +22,7 @@ clock.workspace = true
 collections.workspace = true
 context_server.workspace = true
 editor.workspace = true
+feature_flags.workspace = true
 fs.workspace = true
 futures.workspace = true
 fuzzy.workspace = true
@@ -53,7 +54,9 @@ theme.workspace = true
 ui.workspace = true
 util.workspace = true
 uuid.workspace = true
+workspace-hack.workspace = true
 workspace.workspace = true
+zed_actions.workspace = true
 
 [dev-dependencies]
 language_model = { workspace = true, features = ["test-support"] }

crates/assistant_context_editor/src/context.rs

@@ -40,7 +40,7 @@ use std::{
     sync::Arc,
     time::{Duration, Instant},
 };
-use telemetry_events::{AssistantEvent, AssistantKind, AssistantPhase};
+use telemetry_events::{AssistantEventData, AssistantKind, AssistantPhase};
 use text::{BufferSnapshot, ToPoint};
 use ui::IconName;
 use util::{ResultExt, TryFutureExt, post_inc};
@@ -1272,7 +1272,7 @@ impl AssistantContext {
         // Assume it will be a Chat request, even though that takes fewer tokens (and risks going over the limit),
         // because otherwise you see in the UI that your empty message has a bunch of tokens already used.
         let request = self.to_completion_request(RequestType::Chat, cx);
-        let Some(model) = LanguageModelRegistry::read_global(cx).active_model() else {
+        let Some(model) = LanguageModelRegistry::read_global(cx).default_model() else {
             return;
         };
         let debounce = self.token_count.is_some();
@@ -1284,10 +1284,12 @@ impl AssistantContext {
                         .await;
                 }
 
-                let token_count = cx.update(|cx| model.count_tokens(request, cx))?.await?;
+                let token_count = cx
+                    .update(|cx| model.model.count_tokens(request, cx))?
+                    .await?;
                 this.update(cx, |this, cx| {
                     this.token_count = Some(token_count);
-                    this.start_cache_warming(&model, cx);
+                    this.start_cache_warming(&model.model, cx);
                     cx.notify()
                 })
             }
@@ -2304,14 +2306,16 @@ impl AssistantContext {
         cx: &mut Context<Self>,
     ) -> Option<MessageAnchor> {
         let model_registry = LanguageModelRegistry::read_global(cx);
-        let provider = model_registry.active_provider()?;
-        let model = model_registry.active_model()?;
+        let model = model_registry.default_model()?;
         let last_message_id = self.get_last_valid_message_id(cx)?;
 
-        if !provider.is_authenticated(cx) {
+        if !model.provider.is_authenticated(cx) {
             log::info!("completion provider has no credentials");
             return None;
         }
+
+        let model = model.model;
+
         // Compute which messages to cache, including the last one.
         self.mark_cache_anchors(&model.cache_configuration(), false, cx);
 
@@ -2494,7 +2498,7 @@ impl AssistantContext {
                         .language()
                         .map(|language| language.name());
                     report_assistant_event(
-                        AssistantEvent {
+                        AssistantEventData {
                             conversation_id: Some(this.id.0.clone()),
                             kind: AssistantKind::Panel,
                             phase: AssistantPhase::Response,
@@ -2940,15 +2944,12 @@ impl AssistantContext {
     }
 
     pub fn summarize(&mut self, replace_old: bool, cx: &mut Context<Self>) {
-        let Some(provider) = LanguageModelRegistry::read_global(cx).active_provider() else {
-            return;
-        };
-        let Some(model) = LanguageModelRegistry::read_global(cx).active_model() else {
+        let Some(model) = LanguageModelRegistry::read_global(cx).default_model() else {
             return;
         };
 
         if replace_old || (self.message_anchors.len() >= 2 && self.summary.is_none()) {
-            if !provider.is_authenticated(cx) {
+            if !model.provider.is_authenticated(cx) {
                 return;
             }
 
@@ -2964,7 +2965,7 @@ impl AssistantContext {
 
             self.pending_summary = cx.spawn(async move |this, cx| {
                 async move {
-                    let stream = model.stream_completion_text(request, &cx);
+                    let stream = model.model.stream_completion_text(request, &cx);
                     let mut messages = stream.await?;
 
                     let mut replaced = !replace_old;

crates/assistant_context_editor/src/context_editor.rs

@@ -18,6 +18,7 @@ use editor::{
     scroll::Autoscroll,
 };
 use editor::{FoldPlaceholder, display_map::CreaseId};
+use feature_flags::{Assistant2FeatureFlag, FeatureFlagAppExt as _};
 use fs::Fs;
 use futures::FutureExt;
 use gpui::{
@@ -56,8 +57,7 @@ use ui::{
 use util::{ResultExt, maybe};
 use workspace::searchable::{Direction, SearchableItemHandle};
 use workspace::{
-    Save, ShowConfiguration, Toast, ToolbarItemEvent, ToolbarItemLocation, ToolbarItemView,
-    Workspace,
+    Save, Toast, ToolbarItemEvent, ToolbarItemLocation, ToolbarItemView, Workspace,
     item::{self, FollowableItem, Item, ItemHandle},
     notifications::NotificationId,
     pane::{self, SaveIntent},
@@ -384,7 +384,9 @@ impl ContextEditor {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        let provider = LanguageModelRegistry::read_global(cx).active_provider();
+        let provider = LanguageModelRegistry::read_global(cx)
+            .default_model()
+            .map(|default| default.provider);
         if provider
             .as_ref()
             .map_or(false, |provider| provider.must_accept_terms(cx))
@@ -1560,7 +1562,7 @@ impl ContextEditor {
                 })
             };
             let create_block_properties = |message: &Message| BlockProperties {
-                height: 2,
+                height: Some(2),
                 style: BlockStyle::Sticky,
                 placement: BlockPlacement::Above(
                     buffer
@@ -2109,7 +2111,7 @@ impl ContextEditor {
                     let image = render_image.clone();
                     anchor.is_valid(&buffer).then(|| BlockProperties {
                         placement: BlockPlacement::Above(anchor),
-                        height: MAX_HEIGHT_IN_LINES,
+                        height: Some(MAX_HEIGHT_IN_LINES),
                         style: BlockStyle::Sticky,
                         render: Arc::new(move |cx| {
                             let image_size = size_for_image(
@@ -2357,7 +2359,19 @@ impl ContextEditor {
                             .on_click({
                                 let focus_handle = self.focus_handle(cx).clone();
                                 move |_event, window, cx| {
-                                    focus_handle.dispatch_action(&ShowConfiguration, window, cx);
+                                    if cx.has_flag::<Assistant2FeatureFlag>() {
+                                        focus_handle.dispatch_action(
+                                            &zed_actions::agent::OpenConfiguration,
+                                            window,
+                                            cx,
+                                        );
+                                    } else {
+                                        focus_handle.dispatch_action(
+                                            &zed_actions::assistant::ShowConfiguration,
+                                            window,
+                                            cx,
+                                        );
+                                    };
                                 }
                             }),
                     )
@@ -2395,13 +2409,13 @@ impl ContextEditor {
             None => (ButtonStyle::Filled, None),
         };
 
-        let provider = LanguageModelRegistry::read_global(cx).active_provider();
+        let model = LanguageModelRegistry::read_global(cx).default_model();
 
         let has_configuration_error = configuration_error(cx).is_some();
         let needs_to_accept_terms = self.show_accept_terms
-            && provider
+            && model
                 .as_ref()
-                .map_or(false, |provider| provider.must_accept_terms(cx));
+                .map_or(false, |model| model.provider.must_accept_terms(cx));
         let disabled = has_configuration_error || needs_to_accept_terms;
 
         ButtonLike::new("send_button")
@@ -2454,7 +2468,9 @@ impl ContextEditor {
             None => (ButtonStyle::Filled, None),
         };
 
-        let provider = LanguageModelRegistry::read_global(cx).active_provider();
+        let provider = LanguageModelRegistry::read_global(cx)
+            .default_model()
+            .map(|default| default.provider);
 
         let has_configuration_error = configuration_error(cx).is_some();
         let needs_to_accept_terms = self.show_accept_terms
@@ -2500,7 +2516,9 @@ impl ContextEditor {
     }
 
     fn render_language_model_selector(&self, cx: &mut Context<Self>) -> impl IntoElement {
-        let active_model = LanguageModelRegistry::read_global(cx).active_model();
+        let active_model = LanguageModelRegistry::read_global(cx)
+            .default_model()
+            .map(|default| default.model);
         let focus_handle = self.editor().focus_handle(cx).clone();
         let model_name = match active_model {
             Some(model) => model.name().0,
@@ -2775,7 +2793,7 @@ fn render_thought_process_fold_icon_button(
         let button = match status {
             ThoughtProcessStatus::Pending => button
                 .child(
-                    Icon::new(IconName::Brain)
+                    Icon::new(IconName::LightBulb)
                         .size(IconSize::Small)
                         .color(Color::Muted),
                 )
@@ -2790,7 +2808,7 @@ fn render_thought_process_fold_icon_button(
                 ),
             ThoughtProcessStatus::Completed => button
                 .style(ButtonStyle::Filled)
-                .child(Icon::new(IconName::Brain).size(IconSize::Small))
+                .child(Icon::new(IconName::LightBulb).size(IconSize::Small))
                 .child(Label::new("Thought Process").single_line()),
         };
 
@@ -3020,7 +3038,9 @@ impl EventEmitter<SearchEvent> for ContextEditor {}
 
 impl Render for ContextEditor {
     fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let provider = LanguageModelRegistry::read_global(cx).active_provider();
+        let provider = LanguageModelRegistry::read_global(cx)
+            .default_model()
+            .map(|default| default.provider);
         let accept_terms = if self.show_accept_terms {
             provider.as_ref().and_then(|provider| {
                 provider.render_accept_terms(LanguageModelProviderTosView::PromptEditorPopup, cx)
@@ -3616,7 +3636,9 @@ enum TokenState {
 fn token_state(context: &Entity<AssistantContext>, cx: &App) -> Option<TokenState> {
     const WARNING_TOKEN_THRESHOLD: f32 = 0.8;
 
-    let model = LanguageModelRegistry::read_global(cx).active_model()?;
+    let model = LanguageModelRegistry::read_global(cx)
+        .default_model()?
+        .model;
     let token_count = context.read(cx).token_count()?;
     let max_token_count = model.max_token_count();
 
@@ -3669,16 +3691,16 @@ pub enum ConfigurationError {
 }
 
 fn configuration_error(cx: &App) -> Option<ConfigurationError> {
-    let provider = LanguageModelRegistry::read_global(cx).active_provider();
-    let is_authenticated = provider
+    let model = LanguageModelRegistry::read_global(cx).default_model();
+    let is_authenticated = model
         .as_ref()
-        .map_or(false, |provider| provider.is_authenticated(cx));
+        .map_or(false, |model| model.provider.is_authenticated(cx));
 
-    if provider.is_some() && is_authenticated {
+    if model.is_some() && is_authenticated {
         return None;
     }
 
-    if provider.is_none() {
+    if model.is_none() {
         return Some(ConfigurationError::NoProvider);
     }
 
@@ -3703,6 +3725,18 @@ pub fn humanize_token_count(count: usize) -> String {
                 format!("{}.{}k", thousands, hundreds)
             }
         }
+        1_000_000..=9_999_999 => {
+            let millions = count / 1_000_000;
+            let hundred_thousands = (count % 1_000_000 + 50_000) / 100_000;
+            if hundred_thousands == 0 {
+                format!("{}M", millions)
+            } else if hundred_thousands == 10 {
+                format!("{}M", millions + 1)
+            } else {
+                format!("{}.{}M", millions, hundred_thousands)
+            }
+        }
+        10_000_000.. => format!("{}M", (count + 500_000) / 1_000_000),
         _ => format!("{}k", (count + 500) / 1000),
     }
 }

crates/assistant_context_editor/src/slash_command.rs

@@ -120,13 +120,14 @@ impl SlashCommandCompletionProvider {
                                         ) as Arc<_>
                                     });
                             Some(project::Completion {
-                                old_range: name_range.clone(),
+                                replace_range: name_range.clone(),
                                 documentation: Some(CompletionDocumentation::SingleLine(
                                     command.description().into(),
                                 )),
                                 new_text,
                                 label: command.label(cx),
                                 icon_path: None,
+                                insert_text_mode: None,
                                 confirm,
                                 source: CompletionSource::Custom,
                             })
@@ -218,7 +219,7 @@ impl SlashCommandCompletionProvider {
                             }
 
                             project::Completion {
-                                old_range: if new_argument.replace_previous_arguments {
+                                replace_range: if new_argument.replace_previous_arguments {
                                     argument_range.clone()
                                 } else {
                                     last_argument_range.clone()
@@ -228,6 +229,7 @@ impl SlashCommandCompletionProvider {
                                 new_text,
                                 documentation: None,
                                 confirm,
+                                insert_text_mode: None,
                                 source: CompletionSource::Custom,
                             }
                         })

crates/assistant_eval/README.md

@@ -1,77 +0,0 @@
-# Tool Evals
-
-A framework for evaluating and benchmarking AI assistant performance in the Zed editor.
-
-## Overview
-
-Tool Evals provides a headless environment for running assistants evaluations on code repositories. It automates the process of:
-
-1. Cloning and setting up test repositories
-2. Sending prompts to language models
-3. Allowing the assistant to use tools to modify code
-4. Collecting metrics on performance
-5. Evaluating results against known good solutions
-
-## How It Works
-
-The system consists of several key components:
-
-- **Eval**: Loads test cases from the evaluation_data directory, clones repos, and executes evaluations
-- **HeadlessAssistant**: Provides a headless environment for running the AI assistant
-- **Judge**: Compares AI-generated diffs with reference solutions and scores their functional similarity
-
-The evaluation flow:
-1. An evaluation is loaded from the evaluation_data directory
-2. The target repository is cloned and checked out at a specific commit
-3. A HeadlessAssistant instance is created with the specified language model
-4. The user prompt is sent to the assistant
-5. The assistant responds and uses tools to modify code
-6. Upon completion, a diff is generated from the changes
-7. Results are saved including the diff, assistant's response, and performance metrics
-8. If a reference solution exists, a Judge evaluates the similarity of the solution
-
-## Setup Requirements
-
-### Prerequisites
-
-- Rust and Cargo
-- Git
-- Network access to clone repositories
-- Appropriate API keys for language models and git services (Anthropic, GitHub, etc.)
-
-### Environment Variables
-
-Ensure you have the required API keys set, either from a dev run of Zed or via these environment variables:
-- `ZED_ANTHROPIC_API_KEY` for Claude models
-- `ZED_OPENAI_API_KEY` for OpenAI models
-- `ZED_GITHUB_API_KEY` for GitHub API (or similar)
-
-## Usage
-
-### Running a Single Evaluation
-
-To run a specific evaluation:
-
-```bash
-cargo run -p assistant_eval -- bubbletea-add-set-window-title
-```
-
-The arguments are regex patterns for the evaluation names to run, so to run all evaluations that contain `bubbletea`, run:
-
-```bash
-cargo run -p assistant_eval -- bubbletea
-```
-
-To run all evaluations:
-
-```bash
-cargo run -p assistant_eval -- --all
-```
-
-## Evaluation Data Structure
-
-Each evaluation should be placed in the `evaluation_data` directory with the following structure:
-
-* `prompt.txt`: The user's prompt.
-* `original.diff`: The `git diff` of the change anticipated for this prompt.
-* `setup.json`: Information about the repo used for the evaluation.

crates/assistant_eval/build.rs

@@ -1,52 +0,0 @@
-// Copied from `crates/zed/build.rs`, with removal of code for including the zed icon on windows.
-
-use std::process::Command;
-
-fn main() {
-    if cfg!(target_os = "macos") {
-        println!("cargo:rustc-env=MACOSX_DEPLOYMENT_TARGET=10.15.7");
-
-        // Weakly link ReplayKit to ensure Zed can be used on macOS 10.15+.
-        println!("cargo:rustc-link-arg=-Wl,-weak_framework,ReplayKit");
-
-        // Seems to be required to enable Swift concurrency
-        println!("cargo:rustc-link-arg=-Wl,-rpath,/usr/lib/swift");
-
-        // Register exported Objective-C selectors, protocols, etc
-        println!("cargo:rustc-link-arg=-Wl,-ObjC");
-    }
-
-    // Populate git sha environment variable if git is available
-    println!("cargo:rerun-if-changed=../../.git/logs/HEAD");
-    println!(
-        "cargo:rustc-env=TARGET={}",
-        std::env::var("TARGET").unwrap()
-    );
-    if let Ok(output) = Command::new("git").args(["rev-parse", "HEAD"]).output() {
-        if output.status.success() {
-            let git_sha = String::from_utf8_lossy(&output.stdout);
-            let git_sha = git_sha.trim();
-
-            println!("cargo:rustc-env=ZED_COMMIT_SHA={git_sha}");
-
-            if let Ok(build_profile) = std::env::var("PROFILE") {
-                if build_profile == "release" {
-                    // This is currently the best way to make `cargo build ...`'s build script
-                    // to print something to stdout without extra verbosity.
-                    println!(
-                        "cargo:warning=Info: using '{git_sha}' hash for ZED_COMMIT_SHA env var"
-                    );
-                }
-            }
-        }
-    }
-
-    #[cfg(target_os = "windows")]
-    {
-        #[cfg(target_env = "msvc")]
-        {
-            // todo(windows): This is to avoid stack overflow. Remove it when solved.
-            println!("cargo:rustc-link-arg=/stack:{}", 8 * 1024 * 1024);
-        }
-    }
-}

crates/assistant_eval/src/eval.rs

@@ -1,267 +0,0 @@
-use crate::headless_assistant::{HeadlessAppState, HeadlessAssistant};
-use agent::RequestKind;
-use anyhow::anyhow;
-use collections::HashMap;
-use gpui::{App, Task};
-use language_model::{LanguageModel, TokenUsage};
-use serde::{Deserialize, Serialize};
-use std::{
-    fs,
-    io::Write,
-    path::{Path, PathBuf},
-    sync::Arc,
-    time::Duration,
-};
-use util::command::new_smol_command;
-
-pub struct Eval {
-    pub name: String,
-    pub path: PathBuf,
-    pub repo_path: PathBuf,
-    pub eval_setup: EvalSetup,
-    pub user_prompt: String,
-}
-
-#[derive(Debug, Serialize)]
-pub struct EvalOutput {
-    pub diff: String,
-    pub last_message: String,
-    pub elapsed_time: Duration,
-    pub assistant_response_count: usize,
-    pub tool_use_counts: HashMap<Arc<str>, u32>,
-    pub token_usage: TokenUsage,
-}
-
-#[derive(Deserialize)]
-pub struct EvalSetup {
-    pub url: String,
-    pub base_sha: String,
-}
-
-impl Eval {
-    /// Loads the eval from a path (typically in `evaluation_data`). Clones and checks out the repo
-    /// if necessary.
-    pub async fn load(name: String, path: PathBuf, repos_dir: &Path) -> anyhow::Result<Self> {
-        let prompt_path = path.join("prompt.txt");
-        let user_prompt = smol::unblock(|| std::fs::read_to_string(prompt_path)).await?;
-        let setup_path = path.join("setup.json");
-        let setup_contents = smol::unblock(|| std::fs::read_to_string(setup_path)).await?;
-        let eval_setup = serde_json_lenient::from_str_lenient::<EvalSetup>(&setup_contents)?;
-        let repo_path = repos_dir.join(repo_dir_name(&eval_setup.url));
-        Ok(Eval {
-            name,
-            path,
-            repo_path,
-            eval_setup,
-            user_prompt,
-        })
-    }
-
-    pub fn run(
-        self,
-        app_state: Arc<HeadlessAppState>,
-        model: Arc<dyn LanguageModel>,
-        cx: &mut App,
-    ) -> Task<anyhow::Result<EvalOutput>> {
-        cx.spawn(async move |cx| {
-            checkout_repo(&self.eval_setup, &self.repo_path).await?;
-
-            let (assistant, done_rx) =
-                cx.update(|cx| HeadlessAssistant::new(app_state.clone(), cx))??;
-
-            let _worktree = assistant
-                .update(cx, |assistant, cx| {
-                    assistant.project.update(cx, |project, cx| {
-                        project.create_worktree(&self.repo_path, true, cx)
-                    })
-                })?
-                .await?;
-
-            let start_time = std::time::SystemTime::now();
-
-            let (system_prompt_context, load_error) = cx
-                .update(|cx| {
-                    assistant
-                        .read(cx)
-                        .thread
-                        .read(cx)
-                        .load_system_prompt_context(cx)
-                })?
-                .await;
-
-            if let Some(load_error) = load_error {
-                return Err(anyhow!("{:?}", load_error));
-            };
-
-            assistant.update(cx, |assistant, cx| {
-                assistant.thread.update(cx, |thread, cx| {
-                    let context = vec![];
-                    thread.insert_user_message(self.user_prompt.clone(), context, None, cx);
-                    thread.set_system_prompt_context(system_prompt_context);
-                    thread.send_to_model(model, RequestKind::Chat, cx);
-                });
-            })?;
-
-            done_rx.recv().await??;
-
-            let elapsed_time = start_time.elapsed()?;
-
-            let diff = query_git(&self.repo_path, vec!["diff"]).await?;
-
-            assistant.update(cx, |assistant, cx| {
-                let thread = assistant.thread.read(cx);
-                let last_message = thread.messages().last().unwrap();
-                if last_message.role != language_model::Role::Assistant {
-                    return Err(anyhow!("Last message is not from assistant"));
-                }
-                let assistant_response_count = thread
-                    .messages()
-                    .filter(|message| message.role == language_model::Role::Assistant)
-                    .count();
-                Ok(EvalOutput {
-                    diff,
-                    last_message: last_message.to_string(),
-                    elapsed_time,
-                    assistant_response_count,
-                    tool_use_counts: assistant.tool_use_counts.clone(),
-                    token_usage: thread.cumulative_token_usage(),
-                })
-            })?
-        })
-    }
-}
-
-impl EvalOutput {
-    // Method to save the output to a directory
-    pub fn save_to_directory(
-        &self,
-        output_dir: &Path,
-        eval_output_value: String,
-    ) -> anyhow::Result<()> {
-        // Create the output directory if it doesn't exist
-        fs::create_dir_all(&output_dir)?;
-
-        // Save the diff to a file
-        let diff_path = output_dir.join("diff.patch");
-        let mut diff_file = fs::File::create(&diff_path)?;
-        diff_file.write_all(self.diff.as_bytes())?;
-
-        // Save the last message to a file
-        let message_path = output_dir.join("assistant_response.txt");
-        let mut message_file = fs::File::create(&message_path)?;
-        message_file.write_all(self.last_message.as_bytes())?;
-
-        // Current metrics for this run
-        let current_metrics = serde_json::json!({
-            "elapsed_time_ms": self.elapsed_time.as_millis(),
-            "assistant_response_count": self.assistant_response_count,
-            "tool_use_counts": self.tool_use_counts,
-            "token_usage": self.token_usage,
-            "eval_output_value": eval_output_value,
-        });
-
-        // Get current timestamp in milliseconds
-        let timestamp = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)?
-            .as_millis()
-            .to_string();
-
-        // Path to metrics file
-        let metrics_path = output_dir.join("metrics.json");
-
-        // Load existing metrics if the file exists, or create a new object
-        let mut historical_metrics = if metrics_path.exists() {
-            let metrics_content = fs::read_to_string(&metrics_path)?;
-            serde_json::from_str::<serde_json::Value>(&metrics_content)
-                .unwrap_or_else(|_| serde_json::json!({}))
-        } else {
-            serde_json::json!({})
-        };
-
-        // Add new run with timestamp as key
-        if let serde_json::Value::Object(ref mut map) = historical_metrics {
-            map.insert(timestamp, current_metrics);
-        }
-
-        // Write updated metrics back to file
-        let metrics_json = serde_json::to_string_pretty(&historical_metrics)?;
-        let mut metrics_file = fs::File::create(&metrics_path)?;
-        metrics_file.write_all(metrics_json.as_bytes())?;
-
-        Ok(())
-    }
-}
-
-fn repo_dir_name(url: &str) -> String {
-    url.trim_start_matches("https://")
-        .replace(|c: char| !c.is_alphanumeric(), "_")
-}
-
-async fn checkout_repo(eval_setup: &EvalSetup, repo_path: &Path) -> anyhow::Result<()> {
-    if !repo_path.exists() {
-        smol::unblock({
-            let repo_path = repo_path.to_path_buf();
-            || std::fs::create_dir_all(repo_path)
-        })
-        .await?;
-        run_git(repo_path, vec!["init"]).await?;
-        run_git(repo_path, vec!["remote", "add", "origin", &eval_setup.url]).await?;
-    } else {
-        let actual_origin = query_git(repo_path, vec!["remote", "get-url", "origin"]).await?;
-        if actual_origin != eval_setup.url {
-            return Err(anyhow!(
-                "remote origin {} does not match expected origin {}",
-                actual_origin,
-                eval_setup.url
-            ));
-        }
-
-        // TODO: consider including "-x" to remove ignored files. The downside of this is that it will
-        // also remove build artifacts, and so prevent incremental reuse there.
-        run_git(repo_path, vec!["clean", "--force", "-d"]).await?;
-        run_git(repo_path, vec!["reset", "--hard", "HEAD"]).await?;
-    }
-
-    run_git(
-        repo_path,
-        vec!["fetch", "--depth", "1", "origin", &eval_setup.base_sha],
-    )
-    .await?;
-    run_git(repo_path, vec!["checkout", &eval_setup.base_sha]).await?;
-
-    Ok(())
-}
-
-async fn run_git(repo_path: &Path, args: Vec<&str>) -> anyhow::Result<()> {
-    let exit_status = new_smol_command("git")
-        .current_dir(repo_path)
-        .args(args.clone())
-        .status()
-        .await?;
-    if exit_status.success() {
-        Ok(())
-    } else {
-        Err(anyhow!(
-            "`git {}` failed with {}",
-            args.join(" "),
-            exit_status,
-        ))
-    }
-}
-
-async fn query_git(repo_path: &Path, args: Vec<&str>) -> anyhow::Result<String> {
-    let output = new_smol_command("git")
-        .current_dir(repo_path)
-        .args(args.clone())
-        .output()
-        .await?;
-    if output.status.success() {
-        Ok(String::from_utf8(output.stdout)?.trim().to_string())
-    } else {
-        Err(anyhow!(
-            "`git {}` failed with {}",
-            args.join(" "),
-            output.status
-        ))
-    }
-}

crates/assistant_eval/src/headless_assistant.rs

@@ -1,241 +0,0 @@
-use agent::{RequestKind, Thread, ThreadEvent, ThreadStore};
-use anyhow::anyhow;
-use assistant_tool::ToolWorkingSet;
-use client::{Client, UserStore};
-use collections::HashMap;
-use dap::DapRegistry;
-use futures::StreamExt;
-use gpui::{App, AsyncApp, Entity, SemanticVersion, Subscription, Task, prelude::*};
-use language::LanguageRegistry;
-use language_model::{
-    AuthenticateError, LanguageModel, LanguageModelProviderId, LanguageModelRegistry,
-    LanguageModelRequest,
-};
-use node_runtime::NodeRuntime;
-use project::{Project, RealFs};
-use prompt_store::PromptBuilder;
-use settings::SettingsStore;
-use smol::channel;
-use std::sync::Arc;
-
-/// Subset of `workspace::AppState` needed by `HeadlessAssistant`, with additional fields.
-pub struct HeadlessAppState {
-    pub languages: Arc<LanguageRegistry>,
-    pub client: Arc<Client>,
-    pub user_store: Entity<UserStore>,
-    pub fs: Arc<dyn fs::Fs>,
-    pub node_runtime: NodeRuntime,
-
-    // Additional fields not present in `workspace::AppState`.
-    pub prompt_builder: Arc<PromptBuilder>,
-}
-
-pub struct HeadlessAssistant {
-    pub thread: Entity<Thread>,
-    pub project: Entity<Project>,
-    #[allow(dead_code)]
-    pub thread_store: Entity<ThreadStore>,
-    pub tool_use_counts: HashMap<Arc<str>, u32>,
-    pub done_tx: channel::Sender<anyhow::Result<()>>,
-    _subscription: Subscription,
-}
-
-impl HeadlessAssistant {
-    pub fn new(
-        app_state: Arc<HeadlessAppState>,
-        cx: &mut App,
-    ) -> anyhow::Result<(Entity<Self>, channel::Receiver<anyhow::Result<()>>)> {
-        let env = None;
-        let project = Project::local(
-            app_state.client.clone(),
-            app_state.node_runtime.clone(),
-            app_state.user_store.clone(),
-            app_state.languages.clone(),
-            Arc::new(DapRegistry::default()),
-            app_state.fs.clone(),
-            env,
-            cx,
-        );
-
-        let tools = Arc::new(ToolWorkingSet::default());
-        let thread_store =
-            ThreadStore::new(project.clone(), tools, app_state.prompt_builder.clone(), cx)?;
-
-        let thread = thread_store.update(cx, |thread_store, cx| thread_store.create_thread(cx));
-
-        let (done_tx, done_rx) = channel::unbounded::<anyhow::Result<()>>();
-
-        let headless_thread = cx.new(move |cx| Self {
-            _subscription: cx.subscribe(&thread, Self::handle_thread_event),
-            thread,
-            project,
-            thread_store,
-            tool_use_counts: HashMap::default(),
-            done_tx,
-        });
-
-        Ok((headless_thread, done_rx))
-    }
-
-    fn handle_thread_event(
-        &mut self,
-        thread: Entity<Thread>,
-        event: &ThreadEvent,
-        cx: &mut Context<Self>,
-    ) {
-        match event {
-            ThreadEvent::ShowError(err) => self
-                .done_tx
-                .send_blocking(Err(anyhow!("{:?}", err)))
-                .unwrap(),
-            ThreadEvent::DoneStreaming => {
-                let thread = thread.read(cx);
-                if let Some(message) = thread.messages().last() {
-                    println!("Message: {}", message.to_string());
-                }
-                if thread.all_tools_finished() {
-                    self.done_tx.send_blocking(Ok(())).unwrap()
-                }
-            }
-            ThreadEvent::UsePendingTools => {
-                thread.update(cx, |thread, cx| {
-                    thread.use_pending_tools(cx);
-                });
-            }
-            ThreadEvent::ToolFinished {
-                tool_use_id,
-                pending_tool_use,
-                ..
-            } => {
-                if let Some(pending_tool_use) = pending_tool_use {
-                    println!(
-                        "Used tool {} with input: {}",
-                        pending_tool_use.name, pending_tool_use.input
-                    );
-                    *self
-                        .tool_use_counts
-                        .entry(pending_tool_use.name.clone())
-                        .or_insert(0) += 1;
-                }
-                if let Some(tool_result) = thread.read(cx).tool_result(tool_use_id) {
-                    println!("Tool result: {:?}", tool_result);
-                }
-                if thread.read(cx).all_tools_finished() {
-                    let model_registry = LanguageModelRegistry::read_global(cx);
-                    if let Some(model) = model_registry.active_model() {
-                        thread.update(cx, |thread, cx| {
-                            thread.attach_tool_results(vec![], cx);
-                            thread.send_to_model(model, RequestKind::Chat, cx);
-                        });
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
-}
-
-pub fn init(cx: &mut App) -> Arc<HeadlessAppState> {
-    release_channel::init(SemanticVersion::default(), cx);
-    gpui_tokio::init(cx);
-
-    let mut settings_store = SettingsStore::new(cx);
-    settings_store
-        .set_default_settings(settings::default_settings().as_ref(), cx)
-        .unwrap();
-    cx.set_global(settings_store);
-    client::init_settings(cx);
-    Project::init_settings(cx);
-
-    let client = Client::production(cx);
-    cx.set_http_client(client.http_client().clone());
-
-    let git_binary_path = None;
-    let fs = Arc::new(RealFs::new(
-        git_binary_path,
-        cx.background_executor().clone(),
-    ));
-
-    let languages = Arc::new(LanguageRegistry::new(cx.background_executor().clone()));
-
-    let user_store = cx.new(|cx| UserStore::new(client.clone(), cx));
-
-    language::init(cx);
-    language_model::init(client.clone(), cx);
-    language_models::init(user_store.clone(), client.clone(), fs.clone(), cx);
-    assistant_tools::init(client.http_client().clone(), cx);
-    context_server::init(cx);
-    let stdout_is_a_pty = false;
-    let prompt_builder = PromptBuilder::load(fs.clone(), stdout_is_a_pty, cx);
-    agent::init(fs.clone(), client.clone(), prompt_builder.clone(), cx);
-
-    Arc::new(HeadlessAppState {
-        languages,
-        client,
-        user_store,
-        fs,
-        node_runtime: NodeRuntime::unavailable(),
-        prompt_builder,
-    })
-}
-
-pub fn find_model(model_name: &str, cx: &App) -> anyhow::Result<Arc<dyn LanguageModel>> {
-    let model_registry = LanguageModelRegistry::read_global(cx);
-    let model = model_registry
-        .available_models(cx)
-        .find(|model| model.id().0 == model_name);
-
-    let Some(model) = model else {
-        return Err(anyhow!(
-            "No language model named {} was available. Available models: {}",
-            model_name,
-            model_registry
-                .available_models(cx)
-                .map(|model| model.id().0.clone())
-                .collect::<Vec<_>>()
-                .join(", ")
-        ));
-    };
-
-    Ok(model)
-}
-
-pub fn authenticate_model_provider(
-    provider_id: LanguageModelProviderId,
-    cx: &mut App,
-) -> Task<std::result::Result<(), AuthenticateError>> {
-    let model_registry = LanguageModelRegistry::read_global(cx);
-    let model_provider = model_registry.provider(&provider_id).unwrap();
-    model_provider.authenticate(cx)
-}
-
-pub async fn send_language_model_request(
-    model: Arc<dyn LanguageModel>,
-    request: LanguageModelRequest,
-    cx: &mut AsyncApp,
-) -> anyhow::Result<String> {
-    match model.stream_completion_text(request, &cx).await {
-        Ok(mut stream) => {
-            let mut full_response = String::new();
-
-            // Process the response stream
-            while let Some(chunk_result) = stream.stream.next().await {
-                match chunk_result {
-                    Ok(chunk_str) => {
-                        full_response.push_str(&chunk_str);
-                    }
-                    Err(err) => {
-                        return Err(anyhow!(
-                            "Error receiving response from language model: {err}"
-                        ));
-                    }
-                }
-            }
-
-            Ok(full_response)
-        }
-        Err(err) => Err(anyhow!(
-            "Failed to get response from language model. Error was: {err}"
-        )),
-    }
-}

crates/assistant_eval/src/judge.rs

@@ -1,121 +0,0 @@
-use crate::eval::EvalOutput;
-use crate::headless_assistant::send_language_model_request;
-use anyhow::anyhow;
-use gpui::{App, Task};
-use language_model::{
-    LanguageModel, LanguageModelRequest, LanguageModelRequestMessage, MessageContent, Role,
-};
-use std::{path::Path, sync::Arc};
-
-pub struct Judge {
-    pub original_diff: Option<String>,
-    #[allow(dead_code)]
-    pub original_message: Option<String>,
-    pub model: Arc<dyn LanguageModel>,
-}
-
-impl Judge {
-    pub async fn load(eval_path: &Path, model: Arc<dyn LanguageModel>) -> anyhow::Result<Judge> {
-        let original_diff_path = eval_path.join("original.diff");
-        let original_diff = smol::unblock(move || {
-            if std::fs::exists(&original_diff_path)? {
-                anyhow::Ok(Some(std::fs::read_to_string(&original_diff_path)?))
-            } else {
-                anyhow::Ok(None)
-            }
-        });
-
-        let original_message_path = eval_path.join("original_message.txt");
-        let original_message = smol::unblock(move || {
-            if std::fs::exists(&original_message_path)? {
-                anyhow::Ok(Some(std::fs::read_to_string(&original_message_path)?))
-            } else {
-                anyhow::Ok(None)
-            }
-        });
-
-        Ok(Self {
-            original_diff: original_diff.await?,
-            original_message: original_message.await?,
-            model,
-        })
-    }
-
-    pub fn run(&self, eval_output: &EvalOutput, cx: &mut App) -> Task<anyhow::Result<String>> {
-        let Some(original_diff) = self.original_diff.as_ref() else {
-            return Task::ready(Err(anyhow!("No original.diff found")));
-        };
-
-        // TODO: check for empty diff?
-        let prompt = diff_comparison_prompt(&original_diff, &eval_output.diff);
-
-        let request = LanguageModelRequest {
-            messages: vec![LanguageModelRequestMessage {
-                role: Role::User,
-                content: vec![MessageContent::Text(prompt)],
-                cache: false,
-            }],
-            temperature: Some(0.0),
-            tools: Vec::new(),
-            stop: Vec::new(),
-        };
-
-        let model = self.model.clone();
-        cx.spawn(async move |cx| send_language_model_request(model, request, cx).await)
-    }
-}
-
-pub fn diff_comparison_prompt(original_diff: &str, new_diff: &str) -> String {
-    format!(
-        r#"# Git Diff Similarity Evaluation Template
-
-## Instructions
-
-Compare the two diffs and score them between 0.0 and 1.0 based on their functional similarity.
-- 1.0 = Perfect functional match (achieves identical results)
-- 0.0 = No functional similarity whatsoever
-
-## Evaluation Criteria
-
-Please consider the following aspects in order of importance:
-
-1. **Functional Equivalence (60%)**
-   - Do both diffs achieve the same end result?
-   - Are the changes functionally equivalent despite possibly using different approaches?
-   - Do the modifications address the same issues or implement the same features?
-
-2. **Logical Structure (20%)**
-   - Are the logical flows similar?
-   - Do the modifications affect the same code paths?
-   - Are control structures (if/else, loops, etc.) modified in similar ways?
-
-3. **Code Content (15%)**
-   - Are similar lines added/removed?
-   - Are the same variables, functions, or methods being modified?
-   - Are the same APIs or libraries being used?
-
-4. **File Layout (5%)**
-   - Are the same files being modified?
-   - Are changes occurring in similar locations within files?
-
-## Input
-
-Original Diff:
-```git
-{}
-```
-
-New Diff:
-```git
-{}
-```
-
-## Output Format
-
-THE ONLY OUTPUT SHOULD BE A SCORE BETWEEN 0.0 AND 1.0.
-
-Example output:
-0.85"#,
-        original_diff, new_diff
-    )
-}

crates/assistant_eval/src/main.rs

@@ -1,243 +0,0 @@
-mod eval;
-mod headless_assistant;
-mod judge;
-
-use clap::Parser;
-use eval::{Eval, EvalOutput};
-use futures::future;
-use gpui::{Application, AsyncApp};
-use headless_assistant::{HeadlessAppState, authenticate_model_provider, find_model};
-use itertools::Itertools;
-use judge::Judge;
-use language_model::{LanguageModel, LanguageModelRegistry};
-use regex::Regex;
-use reqwest_client::ReqwestClient;
-use std::{cmp, path::PathBuf, sync::Arc};
-
-#[derive(Parser, Debug)]
-#[command(
-    name = "assistant_eval",
-    disable_version_flag = true,
-    before_help = "Tool eval runner"
-)]
-struct Args {
-    /// Regexes to match the names of evals to run.
-    eval_name_regexes: Vec<String>,
-    /// Runs all evals in `evaluation_data`, causes the regex to be ignored.
-    #[arg(long)]
-    all: bool,
-    /// Name of the model (default: "claude-3-7-sonnet-latest")
-    #[arg(long, default_value = "claude-3-7-sonnet-latest")]
-    model_name: String,
-    /// Name of the editor model (default: value of `--model_name`).
-    #[arg(long)]
-    editor_model_name: Option<String>,
-    /// Name of the judge model (default: value of `--model_name`).
-    #[arg(long)]
-    judge_model_name: Option<String>,
-    /// Number of evaluations to run concurrently (default: 10)
-    #[arg(short, long, default_value = "10")]
-    concurrency: usize,
-}
-
-fn main() {
-    env_logger::init();
-    let args = Args::parse();
-    let http_client = Arc::new(ReqwestClient::new());
-    let app = Application::headless().with_http_client(http_client.clone());
-
-    let crate_dir = PathBuf::from("../zed-agent-bench");
-    let evaluation_data_dir = crate_dir.join("evaluation_data").canonicalize().unwrap();
-
-    let repos_dir = crate_dir.join("repos");
-    if !repos_dir.exists() {
-        std::fs::create_dir_all(&repos_dir).unwrap();
-    }
-    let repos_dir = repos_dir.canonicalize().unwrap();
-
-    let all_evals = std::fs::read_dir(&evaluation_data_dir)
-        .unwrap()
-        .map(|path| path.unwrap().file_name().to_string_lossy().to_string())
-        .collect::<Vec<_>>();
-
-    let evals_to_run = if args.all {
-        all_evals
-    } else {
-        args.eval_name_regexes
-            .into_iter()
-            .map(|regex_string| Regex::new(&regex_string).unwrap())
-            .flat_map(|regex| {
-                all_evals
-                    .iter()
-                    .filter(|eval_name| regex.is_match(eval_name))
-                    .cloned()
-                    .collect::<Vec<_>>()
-            })
-            .collect::<Vec<_>>()
-    };
-
-    if evals_to_run.is_empty() {
-        panic!("Names of evals to run must be provided or `--all` specified");
-    }
-
-    println!("Will run the following evals: {evals_to_run:?}");
-    println!("Running up to {} evals concurrently", args.concurrency);
-
-    let editor_model_name = if let Some(model_name) = args.editor_model_name {
-        model_name
-    } else {
-        args.model_name.clone()
-    };
-
-    let judge_model_name = if let Some(model_name) = args.judge_model_name {
-        model_name
-    } else {
-        args.model_name.clone()
-    };
-
-    app.run(move |cx| {
-        let app_state = headless_assistant::init(cx);
-
-        let model = find_model(&args.model_name, cx).unwrap();
-        let editor_model = find_model(&editor_model_name, cx).unwrap();
-        let judge_model = find_model(&judge_model_name, cx).unwrap();
-
-        LanguageModelRegistry::global(cx).update(cx, |registry, cx| {
-            registry.set_active_model(Some(model.clone()), cx);
-            registry.set_editor_model(Some(editor_model.clone()), cx);
-        });
-
-        let model_provider_id = model.provider_id();
-        let editor_model_provider_id = editor_model.provider_id();
-        let judge_model_provider_id = judge_model.provider_id();
-
-        cx.spawn(async move |cx| {
-            // Authenticate all model providers first
-            cx.update(|cx| authenticate_model_provider(model_provider_id.clone(), cx))
-                .unwrap()
-                .await
-                .unwrap();
-            cx.update(|cx| authenticate_model_provider(editor_model_provider_id.clone(), cx))
-                .unwrap()
-                .await
-                .unwrap();
-            cx.update(|cx| authenticate_model_provider(judge_model_provider_id.clone(), cx))
-                .unwrap()
-                .await
-                .unwrap();
-
-            let eval_load_futures = evals_to_run
-                .into_iter()
-                .map(|eval_name| {
-                    let eval_path = evaluation_data_dir.join(&eval_name);
-                    let load_future = Eval::load(eval_name.clone(), eval_path, &repos_dir);
-                    async move {
-                        match load_future.await {
-                            Ok(eval) => Some(eval),
-                            Err(err) => {
-                                // TODO: Persist errors / surface errors at the end.
-                                println!("Error loading {eval_name}: {err}");
-                                None
-                            }
-                        }
-                    }
-                })
-                .collect::<Vec<_>>();
-
-            let loaded_evals = future::join_all(eval_load_futures)
-                .await
-                .into_iter()
-                .flatten()
-                .collect::<Vec<_>>();
-
-            // The evals need to be loaded and grouped by URL before concurrently running, since
-            // evals that use the same remote URL will use the same working directory.
-            let mut evals_grouped_by_url: Vec<Vec<Eval>> = loaded_evals
-                .into_iter()
-                .map(|eval| (eval.eval_setup.url.clone(), eval))
-                .into_group_map()
-                .into_values()
-                .collect::<Vec<_>>();
-
-            // Sort groups in descending order, so that bigger groups start first.
-            evals_grouped_by_url.sort_by_key(|evals| cmp::Reverse(evals.len()));
-
-            let result_futures = evals_grouped_by_url
-                .into_iter()
-                .map(|evals| {
-                    let model = model.clone();
-                    let judge_model = judge_model.clone();
-                    let app_state = app_state.clone();
-                    let cx = cx.clone();
-
-                    async move {
-                        let mut results = Vec::new();
-                        for eval in evals {
-                            let name = eval.name.clone();
-                            println!("Starting eval named {}", name);
-                            let result = run_eval(
-                                eval,
-                                model.clone(),
-                                judge_model.clone(),
-                                app_state.clone(),
-                                cx.clone(),
-                            )
-                            .await;
-                            results.push((name, result));
-                        }
-                        results
-                    }
-                })
-                .collect::<Vec<_>>();
-
-            let results = future::join_all(result_futures)
-                .await
-                .into_iter()
-                .flatten()
-                .collect::<Vec<_>>();
-
-            // Process results in order of completion
-            for (eval_name, result) in results {
-                match result {
-                    Ok((eval_output, judge_output)) => {
-                        println!("Generated diff for {eval_name}:\n");
-                        println!("{}\n", eval_output.diff);
-                        println!("Last message for {eval_name}:\n");
-                        println!("{}\n", eval_output.last_message);
-                        println!("Elapsed time: {:?}", eval_output.elapsed_time);
-                        println!(
-                            "Assistant response count: {}",
-                            eval_output.assistant_response_count
-                        );
-                        println!("Tool use counts: {:?}", eval_output.tool_use_counts);
-                        println!("Judge output for {eval_name}: {judge_output}");
-                    }
-                    Err(err) => {
-                        // TODO: Persist errors / surface errors at the end.
-                        println!("Error running {eval_name}: {err}");
-                    }
-                }
-            }
-
-            cx.update(|cx| cx.quit()).unwrap();
-        })
-        .detach();
-    });
-
-    println!("Done running evals");
-}
-
-async fn run_eval(
-    eval: Eval,
-    model: Arc<dyn LanguageModel>,
-    judge_model: Arc<dyn LanguageModel>,
-    app_state: Arc<HeadlessAppState>,
-    cx: AsyncApp,
-) -> anyhow::Result<(EvalOutput, String)> {
-    let path = eval.path.clone();
-    let judge = Judge::load(&path, judge_model).await?;
-    let eval_output = cx.update(|cx| eval.run(app_state, model, cx))?.await?;
-    let judge_output = cx.update(|cx| judge.run(&eval_output, cx))?.await?;
-    eval_output.save_to_directory(&path, judge_output.to_string())?;
-    Ok((eval_output, judge_output))
-}

crates/assistant_settings/Cargo.toml

@@ -26,6 +26,7 @@ deepseek = { workspace = true, features = ["schemars"] }
 schemars.workspace = true
 serde.workspace = true
 settings.workspace = true
+workspace-hack.workspace = true
 
 [dev-dependencies]
 fs.workspace = true

crates/assistant_settings/src/assistant_settings.rs

@@ -69,7 +69,7 @@ pub enum AssistantProviderContentV1 {
     },
 }
 
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct AssistantSettings {
     pub enabled: bool,
     pub button: bool,
@@ -77,7 +77,9 @@ pub struct AssistantSettings {
     pub default_width: Pixels,
     pub default_height: Pixels,
     pub default_model: LanguageModelSelection,
-    pub editor_model: LanguageModelSelection,
+    pub inline_assistant_model: Option<LanguageModelSelection>,
+    pub commit_message_model: Option<LanguageModelSelection>,
+    pub thread_summary_model: Option<LanguageModelSelection>,
     pub inline_alternatives: Vec<LanguageModelSelection>,
     pub using_outdated_settings_version: bool,
     pub enable_experimental_live_diffs: bool,
@@ -95,13 +97,25 @@ impl AssistantSettings {
 
         cx.is_staff() || self.enable_experimental_live_diffs
     }
+
+    pub fn set_inline_assistant_model(&mut self, provider: String, model: String) {
+        self.inline_assistant_model = Some(LanguageModelSelection { provider, model });
+    }
+
+    pub fn set_commit_message_model(&mut self, provider: String, model: String) {
+        self.commit_message_model = Some(LanguageModelSelection { provider, model });
+    }
+
+    pub fn set_thread_summary_model(&mut self, provider: String, model: String) {
+        self.thread_summary_model = Some(LanguageModelSelection { provider, model });
+    }
 }
 
 /// Assistant panel settings
 #[derive(Clone, Serialize, Deserialize, Debug)]
 #[serde(untagged)]
 pub enum AssistantSettingsContent {
-    Versioned(VersionedAssistantSettingsContent),
+    Versioned(Box<VersionedAssistantSettingsContent>),
     Legacy(LegacyAssistantSettingsContent),
 }
 
@@ -121,14 +135,14 @@ impl JsonSchema for AssistantSettingsContent {
 
 impl Default for AssistantSettingsContent {
     fn default() -> Self {
-        Self::Versioned(VersionedAssistantSettingsContent::default())
+        Self::Versioned(Box::new(VersionedAssistantSettingsContent::default()))
     }
 }
 
 impl AssistantSettingsContent {
     pub fn is_version_outdated(&self) -> bool {
         match self {
-            AssistantSettingsContent::Versioned(settings) => match settings {
+            AssistantSettingsContent::Versioned(settings) => match **settings {
                 VersionedAssistantSettingsContent::V1(_) => true,
                 VersionedAssistantSettingsContent::V2(_) => false,
             },
@@ -138,8 +152,8 @@ impl AssistantSettingsContent {
 
     fn upgrade(&self) -> AssistantSettingsContentV2 {
         match self {
-            AssistantSettingsContent::Versioned(settings) => match settings {
-                VersionedAssistantSettingsContent::V1(settings) => AssistantSettingsContentV2 {
+            AssistantSettingsContent::Versioned(settings) => match **settings {
+                VersionedAssistantSettingsContent::V1(ref settings) => AssistantSettingsContentV2 {
                     enabled: settings.enabled,
                     button: settings.button,
                     dock: settings.dock,
@@ -186,7 +200,9 @@ impl AssistantSettingsContent {
                                 })
                             }
                         }),
-                    editor_model: None,
+                    inline_assistant_model: None,
+                    commit_message_model: None,
+                    thread_summary_model: None,
                     inline_alternatives: None,
                     enable_experimental_live_diffs: None,
                     default_profile: None,
@@ -194,7 +210,7 @@ impl AssistantSettingsContent {
                     always_allow_tool_actions: None,
                     notify_when_agent_waiting: None,
                 },
-                VersionedAssistantSettingsContent::V2(settings) => settings.clone(),
+                VersionedAssistantSettingsContent::V2(ref settings) => settings.clone(),
             },
             AssistantSettingsContent::Legacy(settings) => AssistantSettingsContentV2 {
                 enabled: None,
@@ -211,7 +227,9 @@ impl AssistantSettingsContent {
                         .id()
                         .to_string(),
                 }),
-                editor_model: None,
+                inline_assistant_model: None,
+                commit_message_model: None,
+                thread_summary_model: None,
                 inline_alternatives: None,
                 enable_experimental_live_diffs: None,
                 default_profile: None,
@@ -224,11 +242,11 @@ impl AssistantSettingsContent {
 
     pub fn set_dock(&mut self, dock: AssistantDockPosition) {
         match self {
-            AssistantSettingsContent::Versioned(settings) => match settings {
-                VersionedAssistantSettingsContent::V1(settings) => {
+            AssistantSettingsContent::Versioned(settings) => match **settings {
+                VersionedAssistantSettingsContent::V1(ref mut settings) => {
                     settings.dock = Some(dock);
                 }
-                VersionedAssistantSettingsContent::V2(settings) => {
+                VersionedAssistantSettingsContent::V2(ref mut settings) => {
                     settings.dock = Some(dock);
                 }
             },
@@ -243,77 +261,79 @@ impl AssistantSettingsContent {
         let provider = language_model.provider_id().0.to_string();
 
         match self {
-            AssistantSettingsContent::Versioned(settings) => match settings {
-                VersionedAssistantSettingsContent::V1(settings) => match provider.as_ref() {
-                    "zed.dev" => {
-                        log::warn!("attempted to set zed.dev model on outdated settings");
-                    }
-                    "anthropic" => {
-                        let api_url = match &settings.provider {
-                            Some(AssistantProviderContentV1::Anthropic { api_url, .. }) => {
-                                api_url.clone()
-                            }
-                            _ => None,
-                        };
-                        settings.provider = Some(AssistantProviderContentV1::Anthropic {
-                            default_model: AnthropicModel::from_id(&model).ok(),
-                            api_url,
-                        });
-                    }
-                    "ollama" => {
-                        let api_url = match &settings.provider {
-                            Some(AssistantProviderContentV1::Ollama { api_url, .. }) => {
-                                api_url.clone()
-                            }
-                            _ => None,
-                        };
-                        settings.provider = Some(AssistantProviderContentV1::Ollama {
-                            default_model: Some(ollama::Model::new(&model, None, None)),
-                            api_url,
-                        });
-                    }
-                    "lmstudio" => {
-                        let api_url = match &settings.provider {
-                            Some(AssistantProviderContentV1::LmStudio { api_url, .. }) => {
-                                api_url.clone()
-                            }
-                            _ => None,
-                        };
-                        settings.provider = Some(AssistantProviderContentV1::LmStudio {
-                            default_model: Some(lmstudio::Model::new(&model, None, None)),
-                            api_url,
-                        });
-                    }
-                    "openai" => {
-                        let (api_url, available_models) = match &settings.provider {
-                            Some(AssistantProviderContentV1::OpenAi {
+            AssistantSettingsContent::Versioned(settings) => match **settings {
+                VersionedAssistantSettingsContent::V1(ref mut settings) => {
+                    match provider.as_ref() {
+                        "zed.dev" => {
+                            log::warn!("attempted to set zed.dev model on outdated settings");
+                        }
+                        "anthropic" => {
+                            let api_url = match &settings.provider {
+                                Some(AssistantProviderContentV1::Anthropic { api_url, .. }) => {
+                                    api_url.clone()
+                                }
+                                _ => None,
+                            };
+                            settings.provider = Some(AssistantProviderContentV1::Anthropic {
+                                default_model: AnthropicModel::from_id(&model).ok(),
+                                api_url,
+                            });
+                        }
+                        "ollama" => {
+                            let api_url = match &settings.provider {
+                                Some(AssistantProviderContentV1::Ollama { api_url, .. }) => {
+                                    api_url.clone()
+                                }
+                                _ => None,
+                            };
+                            settings.provider = Some(AssistantProviderContentV1::Ollama {
+                                default_model: Some(ollama::Model::new(&model, None, None)),
+                                api_url,
+                            });
+                        }
+                        "lmstudio" => {
+                            let api_url = match &settings.provider {
+                                Some(AssistantProviderContentV1::LmStudio { api_url, .. }) => {
+                                    api_url.clone()
+                                }
+                                _ => None,
+                            };
+                            settings.provider = Some(AssistantProviderContentV1::LmStudio {
+                                default_model: Some(lmstudio::Model::new(&model, None, None)),
+                                api_url,
+                            });
+                        }
+                        "openai" => {
+                            let (api_url, available_models) = match &settings.provider {
+                                Some(AssistantProviderContentV1::OpenAi {
+                                    api_url,
+                                    available_models,
+                                    ..
+                                }) => (api_url.clone(), available_models.clone()),
+                                _ => (None, None),
+                            };
+                            settings.provider = Some(AssistantProviderContentV1::OpenAi {
+                                default_model: OpenAiModel::from_id(&model).ok(),
                                 api_url,
                                 available_models,
-                                ..
-                            }) => (api_url.clone(), available_models.clone()),
-                            _ => (None, None),
-                        };
-                        settings.provider = Some(AssistantProviderContentV1::OpenAi {
-                            default_model: OpenAiModel::from_id(&model).ok(),
-                            api_url,
-                            available_models,
-                        });
+                            });
+                        }
+                        "deepseek" => {
+                            let api_url = match &settings.provider {
+                                Some(AssistantProviderContentV1::DeepSeek { api_url, .. }) => {
+                                    api_url.clone()
+                                }
+                                _ => None,
+                            };
+                            settings.provider = Some(AssistantProviderContentV1::DeepSeek {
+                                default_model: DeepseekModel::from_id(&model).ok(),
+                                api_url,
+                            });
+                        }
+                        _ => {}
                     }
-                    "deepseek" => {
-                        let api_url = match &settings.provider {
-                            Some(AssistantProviderContentV1::DeepSeek { api_url, .. }) => {
-                                api_url.clone()
-                            }
-                            _ => None,
-                        };
-                        settings.provider = Some(AssistantProviderContentV1::DeepSeek {
-                            default_model: DeepseekModel::from_id(&model).ok(),
-                            api_url,
-                        });
-                    }
-                    _ => {}
-                },
-                VersionedAssistantSettingsContent::V2(settings) => {
+                }
+                VersionedAssistantSettingsContent::V2(ref mut settings) => {
                     settings.default_model = Some(LanguageModelSelection { provider, model });
                 }
             },
@@ -325,23 +345,48 @@ impl AssistantSettingsContent {
         }
     }
 
+    pub fn set_inline_assistant_model(&mut self, provider: String, model: String) {
+        if let AssistantSettingsContent::Versioned(boxed) = self {
+            if let VersionedAssistantSettingsContent::V2(ref mut settings) = **boxed {
+                settings.inline_assistant_model = Some(LanguageModelSelection { provider, model });
+            }
+        }
+    }
+
+    pub fn set_commit_message_model(&mut self, provider: String, model: String) {
+        if let AssistantSettingsContent::Versioned(boxed) = self {
+            if let VersionedAssistantSettingsContent::V2(ref mut settings) = **boxed {
+                settings.commit_message_model = Some(LanguageModelSelection { provider, model });
+            }
+        }
+    }
+
+    pub fn set_thread_summary_model(&mut self, provider: String, model: String) {
+        if let AssistantSettingsContent::Versioned(boxed) = self {
+            if let VersionedAssistantSettingsContent::V2(ref mut settings) = **boxed {
+                settings.thread_summary_model = Some(LanguageModelSelection { provider, model });
+            }
+        }
+    }
+
     pub fn set_always_allow_tool_actions(&mut self, allow: bool) {
-        let AssistantSettingsContent::Versioned(VersionedAssistantSettingsContent::V2(settings)) =
-            self
-        else {
+        let AssistantSettingsContent::Versioned(boxed) = self else {
             return;
         };
-        settings.always_allow_tool_actions = Some(allow);
+
+        if let VersionedAssistantSettingsContent::V2(ref mut settings) = **boxed {
+            settings.always_allow_tool_actions = Some(allow);
+        }
     }
 
     pub fn set_profile(&mut self, profile_id: AgentProfileId) {
-        let AssistantSettingsContent::Versioned(VersionedAssistantSettingsContent::V2(settings)) =
-            self
-        else {
+        let AssistantSettingsContent::Versioned(boxed) = self else {
             return;
         };
 
-        settings.default_profile = Some(profile_id);
+        if let VersionedAssistantSettingsContent::V2(ref mut settings) = **boxed {
+            settings.default_profile = Some(profile_id);
+        }
     }
 
     pub fn create_profile(
@@ -349,37 +394,37 @@ impl AssistantSettingsContent {
         profile_id: AgentProfileId,
         profile: AgentProfile,
     ) -> Result<()> {
-        let AssistantSettingsContent::Versioned(VersionedAssistantSettingsContent::V2(settings)) =
-            self
-        else {
+        let AssistantSettingsContent::Versioned(boxed) = self else {
             return Ok(());
         };
 
-        let profiles = settings.profiles.get_or_insert_default();
-        if profiles.contains_key(&profile_id) {
-            bail!("profile with ID '{profile_id}' already exists");
-        }
+        if let VersionedAssistantSettingsContent::V2(ref mut settings) = **boxed {
+            let profiles = settings.profiles.get_or_insert_default();
+            if profiles.contains_key(&profile_id) {
+                bail!("profile with ID '{profile_id}' already exists");
+            }
 
-        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
-                    .context_servers
-                    .into_iter()
-                    .map(|(server_id, preset)| {
-                        (
-                            server_id,
-                            ContextServerPresetContent {
-                                tools: preset.tools,
-                            },
-                        )
-                    })
-                    .collect(),
-            },
-        );
+            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
+                        .context_servers
+                        .into_iter()
+                        .map(|(server_id, preset)| {
+                            (
+                                server_id,
+                                ContextServerPresetContent {
+                                    tools: preset.tools,
+                                },
+                            )
+                        })
+                        .collect(),
+                },
+            );
+        }
 
         Ok(())
     }
@@ -403,7 +448,9 @@ impl Default for VersionedAssistantSettingsContent {
             default_width: None,
             default_height: None,
             default_model: None,
-            editor_model: None,
+            inline_assistant_model: None,
+            commit_message_model: None,
+            thread_summary_model: None,
             inline_alternatives: None,
             enable_experimental_live_diffs: None,
             default_profile: None,
@@ -436,10 +483,14 @@ pub struct AssistantSettingsContentV2 {
     ///
     /// Default: 320
     default_height: Option<f32>,
-    /// The default model to use when creating new chats.
+    /// The default model to use when creating new chats and for other features when a specific model is not specified.
     default_model: Option<LanguageModelSelection>,
-    /// The model to use when applying edits from the assistant.
-    editor_model: Option<LanguageModelSelection>,
+    /// Model to use for the inline assistant. Defaults to default_model when not specified.
+    inline_assistant_model: Option<LanguageModelSelection>,
+    /// Model to use for generating git commit messages. Defaults to default_model when not specified.
+    commit_message_model: Option<LanguageModelSelection>,
+    /// Model to use for generating thread summaries. Defaults to default_model when not specified.
+    thread_summary_model: Option<LanguageModelSelection>,
     /// Additional models with which to generate alternatives when performing inline assists.
     inline_alternatives: Option<Vec<LanguageModelSelection>>,
     /// Enable experimental live diffs in the assistant panel.
@@ -601,7 +652,15 @@ impl Settings for AssistantSettings {
                 value.default_height.map(Into::into),
             );
             merge(&mut settings.default_model, value.default_model);
-            merge(&mut settings.editor_model, value.editor_model);
+            settings.inline_assistant_model = value
+                .inline_assistant_model
+                .or(settings.inline_assistant_model.take());
+            settings.commit_message_model = value
+                .commit_message_model
+                .or(settings.commit_message_model.take());
+            settings.thread_summary_model = value
+                .thread_summary_model
+                .or(settings.thread_summary_model.take());
             merge(&mut settings.inline_alternatives, value.inline_alternatives);
             merge(
                 &mut settings.enable_experimental_live_diffs,
@@ -683,7 +742,7 @@ mod tests {
                 AssistantSettings::get_global(cx).default_model,
                 LanguageModelSelection {
                     provider: "zed.dev".into(),
-                    model: "claude-3-5-sonnet-latest".into(),
+                    model: "claude-3-7-sonnet-latest".into(),
                 }
             );
         });
@@ -692,16 +751,15 @@ mod tests {
             settings::SettingsStore::global(cx).update_settings_file::<AssistantSettings>(
                 fs.clone(),
                 |settings, _| {
-                    *settings = AssistantSettingsContent::Versioned(
+                    *settings = AssistantSettingsContent::Versioned(Box::new(
                         VersionedAssistantSettingsContent::V2(AssistantSettingsContentV2 {
                             default_model: Some(LanguageModelSelection {
                                 provider: "test-provider".into(),
                                 model: "gpt-99".into(),
                             }),
-                            editor_model: Some(LanguageModelSelection {
-                                provider: "test-provider".into(),
-                                model: "gpt-99".into(),
-                            }),
+                            inline_assistant_model: None,
+                            commit_message_model: None,
+                            thread_summary_model: None,
                             inline_alternatives: None,
                             enabled: None,
                             button: None,
@@ -714,7 +772,7 @@ mod tests {
                             always_allow_tool_actions: None,
                             notify_when_agent_waiting: None,
                         }),
-                    )
+                    ))
                 },
             );
         });

crates/assistant_slash_command/Cargo.toml

@@ -26,6 +26,7 @@ serde.workspace = true
 serde_json.workspace = true
 ui.workspace = true
 workspace.workspace = true
+workspace-hack.workspace = true
 
 [dev-dependencies]
 gpui = { workspace = true, features = ["test-support"] }

crates/assistant_slash_commands/Cargo.toml

@@ -42,6 +42,7 @@ ui.workspace = true
 util.workspace = true
 workspace.workspace = true
 worktree.workspace = true
+workspace-hack.workspace = true
 
 [dev-dependencies]
 env_logger.workspace = true

crates/assistant_tool/Cargo.toml

@@ -28,6 +28,7 @@ serde.workspace = true
 serde_json.workspace = true
 text.workspace = true
 util.workspace = true
+workspace-hack.workspace = true
 
 [dev-dependencies]
 buffer_diff = { workspace = true, features = ["test-support"] }

crates/assistant_tool/src/action_log.rs

@@ -1,31 +1,31 @@
 use anyhow::{Context as _, Result};
 use buffer_diff::BufferDiff;
-use collections::{BTreeMap, HashSet};
+use collections::BTreeMap;
 use futures::{StreamExt, channel::mpsc};
 use gpui::{App, AppContext, AsyncApp, Context, Entity, Subscription, Task, WeakEntity};
 use language::{Anchor, Buffer, BufferEvent, DiskState, Point};
+use project::{Project, ProjectItem, lsp_store::OpenLspBufferHandle};
 use std::{cmp, ops::Range, sync::Arc};
 use text::{Edit, Patch, Rope};
 use util::RangeExt;
 
 /// Tracks actions performed by tools in a thread
 pub struct ActionLog {
-    /// Buffers that user manually added to the context, and whose content has
-    /// changed since the model last saw them.
-    stale_buffers_in_context: HashSet<Entity<Buffer>>,
     /// Buffers that we want to notify the model about when they change.
     tracked_buffers: BTreeMap<Entity<Buffer>, TrackedBuffer>,
     /// Has the model edited a file since it last checked diagnostics?
     edited_since_project_diagnostics_check: bool,
+    /// The project this action log is associated with
+    project: Entity<Project>,
 }
 
 impl ActionLog {
-    /// Creates a new, empty action log.
-    pub fn new() -> Self {
+    /// Creates a new, empty action log associated with the given project.
+    pub fn new(project: Entity<Project>) -> Self {
         Self {
-            stale_buffers_in_context: HashSet::default(),
             tracked_buffers: BTreeMap::default(),
             edited_since_project_diagnostics_check: false,
+            project,
         }
     }
 
@@ -49,6 +49,10 @@ impl ActionLog {
             .tracked_buffers
             .entry(buffer.clone())
             .or_insert_with(|| {
+                let open_lsp_handle = self.project.update(cx, |project, cx| {
+                    project.register_buffer_with_language_servers(&buffer, cx)
+                });
+
                 let text_snapshot = buffer.read(cx).text_snapshot();
                 let diff = cx.new(|cx| BufferDiff::new(&text_snapshot, cx));
                 let (diff_update_tx, diff_update_rx) = mpsc::unbounded();
@@ -76,6 +80,7 @@ impl ActionLog {
                     version: buffer.read(cx).version(),
                     diff,
                     diff_update: diff_update_tx,
+                    _open_lsp_handle: open_lsp_handle,
                     _maintain_diff: cx.spawn({
                         let buffer = buffer.clone();
                         async move |this, cx| {
@@ -259,6 +264,11 @@ impl ActionLog {
         self.track_buffer(buffer, false, cx);
     }
 
+    /// Track a buffer that was added as context, so we can notify the model about user edits.
+    pub fn buffer_added_as_context(&mut self, buffer: Entity<Buffer>, cx: &mut Context<Self>) {
+        self.track_buffer(buffer, false, cx);
+    }
+
     /// Track a buffer as read, so we can notify the model about user edits.
     pub fn will_create_buffer(&mut self, buffer: Entity<Buffer>, cx: &mut Context<Self>) {
         self.track_buffer(buffer.clone(), true, cx);
@@ -268,7 +278,6 @@ impl ActionLog {
     /// Mark a buffer as edited, so we can refresh it in the context
     pub fn buffer_edited(&mut self, buffer: Entity<Buffer>, cx: &mut Context<Self>) {
         self.edited_since_project_diagnostics_check = true;
-        self.stale_buffers_in_context.insert(buffer.clone());
 
         let tracked_buffer = self.track_buffer(buffer.clone(), false, cx);
         if let TrackedBufferStatus::Deleted = tracked_buffer.status {
@@ -324,14 +333,14 @@ impl ActionLog {
                     {
                         true
                     } else {
-                        let old_bytes = tracked_buffer
+                        let old_range = tracked_buffer
                             .base_text
                             .point_to_offset(Point::new(edit.old.start, 0))
                             ..tracked_buffer.base_text.point_to_offset(cmp::min(
                                 Point::new(edit.old.end, 0),
                                 tracked_buffer.base_text.max_point(),
                             ));
-                        let new_bytes = tracked_buffer
+                        let new_range = tracked_buffer
                             .snapshot
                             .point_to_offset(Point::new(edit.new.start, 0))
                             ..tracked_buffer.snapshot.point_to_offset(cmp::min(
@@ -339,10 +348,10 @@ impl ActionLog {
                                 tracked_buffer.snapshot.max_point(),
                             ));
                         tracked_buffer.base_text.replace(
-                            old_bytes,
+                            old_range,
                             &tracked_buffer
                                 .snapshot
-                                .text_for_range(new_bytes)
+                                .text_for_range(new_range)
                                 .collect::<String>(),
                         );
                         delta += edit.new_len() as i32 - edit.old_len() as i32;
@@ -354,6 +363,87 @@ impl ActionLog {
         }
     }
 
+    pub fn reject_edits_in_range(
+        &mut self,
+        buffer: Entity<Buffer>,
+        buffer_range: Range<impl language::ToPoint>,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<()>> {
+        let Some(tracked_buffer) = self.tracked_buffers.get_mut(&buffer) else {
+            return Task::ready(Ok(()));
+        };
+
+        match tracked_buffer.status {
+            TrackedBufferStatus::Created => {
+                let delete = buffer
+                    .read(cx)
+                    .entry_id(cx)
+                    .and_then(|entry_id| {
+                        self.project
+                            .update(cx, |project, cx| project.delete_entry(entry_id, false, cx))
+                    })
+                    .unwrap_or(Task::ready(Ok(())));
+                self.tracked_buffers.remove(&buffer);
+                cx.notify();
+                delete
+            }
+            TrackedBufferStatus::Deleted => {
+                buffer.update(cx, |buffer, cx| {
+                    buffer.set_text(tracked_buffer.base_text.to_string(), cx)
+                });
+                let save = self
+                    .project
+                    .update(cx, |project, cx| project.save_buffer(buffer.clone(), cx));
+
+                // Clear all tracked changes for this buffer and start over as if we just read it.
+                self.tracked_buffers.remove(&buffer);
+                self.track_buffer(buffer.clone(), false, cx);
+                cx.notify();
+                save
+            }
+            TrackedBufferStatus::Modified => {
+                buffer.update(cx, |buffer, cx| {
+                    let buffer_range =
+                        buffer_range.start.to_point(buffer)..buffer_range.end.to_point(buffer);
+
+                    let mut edits_to_revert = Vec::new();
+                    for edit in tracked_buffer.unreviewed_changes.edits() {
+                        if buffer_range.end.row < edit.new.start {
+                            break;
+                        } else if buffer_range.start.row > edit.new.end {
+                            continue;
+                        }
+
+                        let old_range = tracked_buffer
+                            .base_text
+                            .point_to_offset(Point::new(edit.old.start, 0))
+                            ..tracked_buffer.base_text.point_to_offset(cmp::min(
+                                Point::new(edit.old.end, 0),
+                                tracked_buffer.base_text.max_point(),
+                            ));
+                        let old_text = tracked_buffer
+                            .base_text
+                            .chunks_in_range(old_range)
+                            .collect::<String>();
+
+                        let new_range = tracked_buffer
+                            .snapshot
+                            .anchor_before(Point::new(edit.new.start, 0))
+                            ..tracked_buffer.snapshot.anchor_after(cmp::min(
+                                Point::new(edit.new.end, 0),
+                                tracked_buffer.snapshot.max_point(),
+                            ));
+                        edits_to_revert.push((new_range, old_text));
+                    }
+
+                    buffer.edit(edits_to_revert, None, cx);
+                });
+                self.project
+                    .update(cx, |project, cx| project.save_buffer(buffer, cx))
+            }
+        }
+    }
+
     pub fn keep_all_edits(&mut self, cx: &mut Context<Self>) {
         self.tracked_buffers
             .retain(|_buffer, tracked_buffer| match tracked_buffer.status {
@@ -391,11 +481,6 @@ impl ActionLog {
             })
             .map(|(buffer, _)| buffer)
     }
-
-    /// Takes and returns the set of buffers pending refresh, clearing internal state.
-    pub fn take_stale_buffers_in_context(&mut self) -> HashSet<Entity<Buffer>> {
-        std::mem::take(&mut self.stale_buffers_in_context)
-    }
 }
 
 fn apply_non_conflicting_edits(
@@ -535,6 +620,7 @@ struct TrackedBuffer {
     diff: Entity<BufferDiff>,
     snapshot: text::BufferSnapshot,
     diff_update: mpsc::UnboundedSender<(ChangeAuthor, text::BufferSnapshot)>,
+    _open_lsp_handle: OpenLspBufferHandle,
     _maintain_diff: Task<()>,
     _subscription: Subscription,
 }
@@ -580,9 +666,22 @@ mod tests {
         }
     }
 
+    fn init_test(cx: &mut TestAppContext) {
+        cx.update(|cx| {
+            let settings_store = SettingsStore::test(cx);
+            cx.set_global(settings_store);
+            language::init(cx);
+            Project::init_settings(cx);
+        });
+    }
+
     #[gpui::test(iterations = 10)]
     async fn test_keep_edits(cx: &mut TestAppContext) {
-        let action_log = cx.new(|_| ActionLog::new());
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+        let project = Project::test(fs.clone(), [], cx).await;
+        let action_log = cx.new(|_| ActionLog::new(project.clone()));
         let buffer = cx.new(|cx| Buffer::local("abc\ndef\nghi\njkl\nmno", cx));
 
         cx.update(|cx| {
@@ -648,7 +747,11 @@ mod tests {
 
     #[gpui::test(iterations = 10)]
     async fn test_deletions(cx: &mut TestAppContext) {
-        let action_log = cx.new(|_| ActionLog::new());
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+        let project = Project::test(fs.clone(), [], cx).await;
+        let action_log = cx.new(|_| ActionLog::new(project.clone()));
         let buffer = cx.new(|cx| Buffer::local("abc\ndef\nghi\njkl\nmno\npqr", cx));
 
         cx.update(|cx| {
@@ -718,7 +821,11 @@ mod tests {
 
     #[gpui::test(iterations = 10)]
     async fn test_overlapping_user_edits(cx: &mut TestAppContext) {
-        let action_log = cx.new(|_| ActionLog::new());
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+        let project = Project::test(fs.clone(), [], cx).await;
+        let action_log = cx.new(|_| ActionLog::new(project.clone()));
         let buffer = cx.new(|cx| Buffer::local("abc\ndef\nghi\njkl\nmno", cx));
 
         cx.update(|cx| {
@@ -802,15 +909,12 @@ mod tests {
     }
 
     #[gpui::test(iterations = 10)]
-    async fn test_creation(cx: &mut TestAppContext) {
-        cx.update(|cx| {
-            let settings_store = SettingsStore::test(cx);
-            cx.set_global(settings_store);
-            language::init(cx);
-            Project::init_settings(cx);
-        });
+    async fn test_creating_files(cx: &mut TestAppContext) {
+        init_test(cx);
 
-        let action_log = cx.new(|_| ActionLog::new());
+        let fs = FakeFs::new(cx.executor());
+        let project = Project::test(fs.clone(), [path!("/dir").as_ref()], cx).await;
+        let action_log = cx.new(|_| ActionLog::new(project.clone()));
 
         let fs = FakeFs::new(cx.executor());
         fs.insert_tree(path!("/dir"), json!({})).await;
@@ -869,12 +973,7 @@ mod tests {
 
     #[gpui::test(iterations = 10)]
     async fn test_deleting_files(cx: &mut TestAppContext) {
-        cx.update(|cx| {
-            let settings_store = SettingsStore::test(cx);
-            cx.set_global(settings_store);
-            language::init(cx);
-            Project::init_settings(cx);
-        });
+        init_test(cx);
 
         let fs = FakeFs::new(cx.executor());
         fs.insert_tree(
@@ -891,7 +990,7 @@ mod tests {
             .read_with(cx, |project, cx| project.find_project_path("dir/file2", cx))
             .unwrap();
 
-        let action_log = cx.new(|_| ActionLog::new());
+        let action_log = cx.new(|_| ActionLog::new(project.clone()));
         let buffer1 = project
             .update(cx, |project, cx| {
                 project.open_buffer(file1_path.clone(), cx)
@@ -981,15 +1080,222 @@ mod tests {
         assert_eq!(unreviewed_hunks(&action_log, cx), vec![]);
     }
 
+    #[gpui::test(iterations = 10)]
+    async fn test_reject_edits(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree(path!("/dir"), json!({"file": "abc\ndef\nghi\njkl\nmno"}))
+            .await;
+        let project = Project::test(fs.clone(), [path!("/dir").as_ref()], cx).await;
+        let action_log = cx.new(|_| ActionLog::new(project.clone()));
+        let file_path = project
+            .read_with(cx, |project, cx| project.find_project_path("dir/file", cx))
+            .unwrap();
+        let buffer = project
+            .update(cx, |project, cx| project.open_buffer(file_path, cx))
+            .await
+            .unwrap();
+
+        cx.update(|cx| {
+            action_log.update(cx, |log, cx| log.buffer_read(buffer.clone(), cx));
+            buffer.update(cx, |buffer, cx| {
+                buffer
+                    .edit([(Point::new(1, 1)..Point::new(1, 2), "E\nXYZ")], None, cx)
+                    .unwrap()
+            });
+            buffer.update(cx, |buffer, cx| {
+                buffer
+                    .edit([(Point::new(5, 2)..Point::new(5, 3), "O")], None, cx)
+                    .unwrap()
+            });
+            action_log.update(cx, |log, cx| log.buffer_edited(buffer.clone(), cx));
+        });
+        cx.run_until_parked();
+        assert_eq!(
+            buffer.read_with(cx, |buffer, _| buffer.text()),
+            "abc\ndE\nXYZf\nghi\njkl\nmnO"
+        );
+        assert_eq!(
+            unreviewed_hunks(&action_log, cx),
+            vec![(
+                buffer.clone(),
+                vec![
+                    HunkStatus {
+                        range: Point::new(1, 0)..Point::new(3, 0),
+                        diff_status: DiffHunkStatusKind::Modified,
+                        old_text: "def\n".into(),
+                    },
+                    HunkStatus {
+                        range: Point::new(5, 0)..Point::new(5, 3),
+                        diff_status: DiffHunkStatusKind::Modified,
+                        old_text: "mno".into(),
+                    }
+                ],
+            )]
+        );
+
+        action_log
+            .update(cx, |log, cx| {
+                log.reject_edits_in_range(buffer.clone(), Point::new(0, 0)..Point::new(1, 0), cx)
+            })
+            .await
+            .unwrap();
+        cx.run_until_parked();
+        assert_eq!(
+            buffer.read_with(cx, |buffer, _| buffer.text()),
+            "abc\ndef\nghi\njkl\nmnO"
+        );
+        assert_eq!(
+            unreviewed_hunks(&action_log, cx),
+            vec![(
+                buffer.clone(),
+                vec![HunkStatus {
+                    range: Point::new(4, 0)..Point::new(4, 3),
+                    diff_status: DiffHunkStatusKind::Modified,
+                    old_text: "mno".into(),
+                }],
+            )]
+        );
+
+        action_log
+            .update(cx, |log, cx| {
+                log.reject_edits_in_range(buffer.clone(), Point::new(4, 0)..Point::new(4, 0), cx)
+            })
+            .await
+            .unwrap();
+        cx.run_until_parked();
+        assert_eq!(
+            buffer.read_with(cx, |buffer, _| buffer.text()),
+            "abc\ndef\nghi\njkl\nmno"
+        );
+        assert_eq!(unreviewed_hunks(&action_log, cx), vec![]);
+    }
+
+    #[gpui::test(iterations = 10)]
+    async fn test_reject_deleted_file(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree(path!("/dir"), json!({"file": "content"}))
+            .await;
+        let project = Project::test(fs.clone(), [path!("/dir").as_ref()], cx).await;
+        let action_log = cx.new(|_| ActionLog::new(project.clone()));
+        let file_path = project
+            .read_with(cx, |project, cx| project.find_project_path("dir/file", cx))
+            .unwrap();
+        let buffer = project
+            .update(cx, |project, cx| project.open_buffer(file_path.clone(), cx))
+            .await
+            .unwrap();
+
+        cx.update(|cx| {
+            action_log.update(cx, |log, cx| log.will_delete_buffer(buffer.clone(), cx));
+        });
+        project
+            .update(cx, |project, cx| {
+                project.delete_file(file_path.clone(), false, cx)
+            })
+            .unwrap()
+            .await
+            .unwrap();
+        cx.run_until_parked();
+        assert!(!fs.is_file(path!("/dir/file").as_ref()).await);
+        assert_eq!(
+            unreviewed_hunks(&action_log, cx),
+            vec![(
+                buffer.clone(),
+                vec![HunkStatus {
+                    range: Point::new(0, 0)..Point::new(0, 0),
+                    diff_status: DiffHunkStatusKind::Deleted,
+                    old_text: "content".into(),
+                }]
+            )]
+        );
+
+        action_log
+            .update(cx, |log, cx| {
+                log.reject_edits_in_range(buffer.clone(), Point::new(0, 0)..Point::new(0, 0), cx)
+            })
+            .await
+            .unwrap();
+        cx.run_until_parked();
+        assert_eq!(buffer.read_with(cx, |buffer, _| buffer.text()), "content");
+        assert!(fs.is_file(path!("/dir/file").as_ref()).await);
+        assert_eq!(unreviewed_hunks(&action_log, cx), vec![]);
+    }
+
+    #[gpui::test(iterations = 10)]
+    async fn test_reject_created_file(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+        let project = Project::test(fs.clone(), [path!("/dir").as_ref()], cx).await;
+        let action_log = cx.new(|_| ActionLog::new(project.clone()));
+        let file_path = project
+            .read_with(cx, |project, cx| {
+                project.find_project_path("dir/new_file", cx)
+            })
+            .unwrap();
+
+        let buffer = project
+            .update(cx, |project, cx| project.open_buffer(file_path, cx))
+            .await
+            .unwrap();
+        cx.update(|cx| {
+            buffer.update(cx, |buffer, cx| buffer.set_text("content", cx));
+            action_log.update(cx, |log, cx| log.will_create_buffer(buffer.clone(), cx));
+        });
+        project
+            .update(cx, |project, cx| project.save_buffer(buffer.clone(), cx))
+            .await
+            .unwrap();
+        assert!(fs.is_file(path!("/dir/new_file").as_ref()).await);
+        cx.run_until_parked();
+        assert_eq!(
+            unreviewed_hunks(&action_log, cx),
+            vec![(
+                buffer.clone(),
+                vec![HunkStatus {
+                    range: Point::new(0, 0)..Point::new(0, 7),
+                    diff_status: DiffHunkStatusKind::Added,
+                    old_text: "".into(),
+                }],
+            )]
+        );
+
+        action_log
+            .update(cx, |log, cx| {
+                log.reject_edits_in_range(buffer.clone(), Point::new(0, 0)..Point::new(0, 11), cx)
+            })
+            .await
+            .unwrap();
+        cx.run_until_parked();
+        assert!(!fs.is_file(path!("/dir/new_file").as_ref()).await);
+        assert_eq!(unreviewed_hunks(&action_log, cx), vec![]);
+    }
+
     #[gpui::test(iterations = 100)]
     async fn test_random_diffs(mut rng: StdRng, cx: &mut TestAppContext) {
+        init_test(cx);
+
         let operations = env::var("OPERATIONS")
             .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
             .unwrap_or(20);
 
-        let action_log = cx.new(|_| ActionLog::new());
         let text = RandomCharIter::new(&mut rng).take(50).collect::<String>();
-        let buffer = cx.new(|cx| Buffer::local(text, cx));
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree(path!("/dir"), json!({"file": text})).await;
+        let project = Project::test(fs.clone(), [path!("/dir").as_ref()], cx).await;
+        let action_log = cx.new(|_| ActionLog::new(project.clone()));
+        let file_path = project
+            .read_with(cx, |project, cx| project.find_project_path("dir/file", cx))
+            .unwrap();
+        let buffer = project
+            .update(cx, |project, cx| project.open_buffer(file_path, cx))
+            .await
+            .unwrap();
+
         action_log.update(cx, |log, cx| log.buffer_read(buffer.clone(), cx));
 
         for _ in 0..operations {
@@ -997,10 +1303,20 @@ mod tests {
                 0..25 => {
                     action_log.update(cx, |log, cx| {
                         let range = buffer.read(cx).random_byte_range(0, &mut rng);
-                        log::info!("keeping all edits in range {:?}", range);
+                        log::info!("keeping edits in range {:?}", range);
                         log.keep_edits_in_range(buffer.clone(), range, cx)
                     });
                 }
+                25..50 => {
+                    action_log
+                        .update(cx, |log, cx| {
+                            let range = buffer.read(cx).random_byte_range(0, &mut rng);
+                            log::info!("rejecting edits in range {:?}", range);
+                            log.reject_edits_in_range(buffer.clone(), range, cx)
+                        })
+                        .await
+                        .unwrap();
+                }
                 _ => {
                     let is_agent_change = rng.gen_bool(0.5);
                     if is_agent_change {

crates/assistant_tool/src/assistant_tool.rs

@@ -48,7 +48,7 @@ pub trait Tool: 'static + Send + Sync {
 
     /// Returns true iff the tool needs the users's confirmation
     /// before having permission to run.
-    fn needs_confirmation(&self) -> bool;
+    fn needs_confirmation(&self, input: &serde_json::Value, cx: &App) -> bool;
 
     /// Returns the JSON schema that describes the tool's input.
     fn input_schema(&self, _: LanguageModelToolSchemaFormat) -> serde_json::Value {

crates/assistant_tools/Cargo.toml

@@ -16,7 +16,6 @@ anyhow.workspace = true
 assistant_tool.workspace = true
 chrono.workspace = true
 collections.workspace = true
-feature_flags.workspace = true
 futures.workspace = true
 gpui.workspace = true
 html_to_markdown.workspace = true
@@ -24,21 +23,16 @@ http_client.workspace = true
 itertools.workspace = true
 language.workspace = true
 language_model.workspace = true
-log.workspace = true
-lsp.workspace = true
 project.workspace = true
 regex.workspace = true
-release_channel.workspace = true
 schemars.workspace = true
 serde.workspace = true
 serde_json.workspace = true
-settings.workspace = true
-theme.workspace = true
 ui.workspace = true
 util.workspace = true
-workspace.workspace = true
 worktree.workspace = true
 open = { workspace = true }
+workspace-hack.workspace = true
 
 [dev-dependencies]
 collections = { workspace = true, features = ["test-support"] }

crates/assistant_tools/src/assistant_tools.rs

@@ -1,13 +1,11 @@
-mod bash_tool;
 mod batch_tool;
-mod code_symbol_iter;
+mod code_action_tool;
 mod code_symbols_tool;
 mod copy_path_tool;
 mod create_directory_tool;
 mod create_file_tool;
 mod delete_path_tool;
 mod diagnostics_tool;
-mod edit_files_tool;
 mod fetch_tool;
 mod find_replace_file_tool;
 mod list_directory_tool;
@@ -17,9 +15,11 @@ mod open_tool;
 mod path_search_tool;
 mod read_file_tool;
 mod regex_search_tool;
+mod rename_tool;
 mod replace;
 mod schema;
 mod symbol_info_tool;
+mod terminal_tool;
 mod thinking_tool;
 
 use std::sync::Arc;
@@ -30,14 +30,13 @@ use gpui::App;
 use http_client::HttpClientWithUrl;
 use move_path_tool::MovePathTool;
 
-use crate::bash_tool::BashTool;
 use crate::batch_tool::BatchTool;
+use crate::code_action_tool::CodeActionTool;
 use crate::code_symbols_tool::CodeSymbolsTool;
 use crate::create_directory_tool::CreateDirectoryTool;
 use crate::create_file_tool::CreateFileTool;
 use crate::delete_path_tool::DeletePathTool;
 use crate::diagnostics_tool::DiagnosticsTool;
-use crate::edit_files_tool::EditFilesTool;
 use crate::fetch_tool::FetchTool;
 use crate::find_replace_file_tool::FindReplaceFileTool;
 use crate::list_directory_tool::ListDirectoryTool;
@@ -46,15 +45,16 @@ use crate::open_tool::OpenTool;
 use crate::path_search_tool::PathSearchTool;
 use crate::read_file_tool::ReadFileTool;
 use crate::regex_search_tool::RegexSearchTool;
+use crate::rename_tool::RenameTool;
 use crate::symbol_info_tool::SymbolInfoTool;
+use crate::terminal_tool::TerminalTool;
 use crate::thinking_tool::ThinkingTool;
 
 pub fn init(http_client: Arc<HttpClientWithUrl>, cx: &mut App) {
     assistant_tool::init(cx);
-    crate::edit_files_tool::log::init(cx);
 
     let registry = ToolRegistry::global(cx);
-    registry.register_tool(BashTool);
+    registry.register_tool(TerminalTool);
     registry.register_tool(BatchTool);
     registry.register_tool(CreateDirectoryTool);
     registry.register_tool(CreateFileTool);
@@ -62,9 +62,9 @@ pub fn init(http_client: Arc<HttpClientWithUrl>, cx: &mut App) {
     registry.register_tool(DeletePathTool);
     registry.register_tool(FindReplaceFileTool);
     registry.register_tool(SymbolInfoTool);
+    registry.register_tool(CodeActionTool);
     registry.register_tool(MovePathTool);
     registry.register_tool(DiagnosticsTool);
-    registry.register_tool(EditFilesTool);
     registry.register_tool(ListDirectoryTool);
     registry.register_tool(NowTool);
     registry.register_tool(OpenTool);
@@ -72,6 +72,41 @@ pub fn init(http_client: Arc<HttpClientWithUrl>, cx: &mut App) {
     registry.register_tool(PathSearchTool);
     registry.register_tool(ReadFileTool);
     registry.register_tool(RegexSearchTool);
+    registry.register_tool(RenameTool);
     registry.register_tool(ThinkingTool);
     registry.register_tool(FetchTool::new(http_client));
 }
+
+#[cfg(test)]
+mod tests {
+    use http_client::FakeHttpClient;
+
+    use super::*;
+
+    #[gpui::test]
+    fn test_tool_schema_compatibility(cx: &mut App) {
+        crate::init(
+            Arc::new(http_client::HttpClientWithUrl::new(
+                FakeHttpClient::with_200_response(),
+                "https://zed.dev",
+                None,
+            )),
+            cx,
+        );
+
+        for tool in ToolRegistry::global(cx).tools() {
+            let schema =
+                tool.input_schema(language_model::LanguageModelToolSchemaFormat::JsonSchemaSubset);
+            assert!(schema.is_object());
+            if schema.as_object().unwrap().contains_key("$schema") {
+                let error_message = format!(
+                    "Tool schema for `{}` is not compatible with `language_model::LanguageModelToolSchemaFormat::JsonSchemaSubset` (Gemini Models).\n\
+                    Are you using `schema::json_schema_for<T>(format)` to generate the schema?",
+                    tool.name()
+                );
+
+                panic!("{}", error_message)
+            }
+        }
+    }
+}

crates/assistant_tools/src/bash_tool.rs

@@ -1,153 +0,0 @@
-use crate::schema::json_schema_for;
-use anyhow::{Context as _, Result, anyhow};
-use assistant_tool::{ActionLog, Tool};
-use gpui::{App, Entity, Task};
-use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
-use project::Project;
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
-use std::path::Path;
-use std::sync::Arc;
-use ui::IconName;
-use util::command::new_smol_command;
-use util::markdown::MarkdownString;
-
-#[derive(Debug, Serialize, Deserialize, JsonSchema)]
-pub struct BashToolInput {
-    /// The bash command to execute as a one-liner.
-    command: String,
-    /// Working directory for the command. This must be one of the root directories of the project.
-    cd: String,
-}
-
-pub struct BashTool;
-
-impl Tool for BashTool {
-    fn name(&self) -> String {
-        "bash".to_string()
-    }
-
-    fn needs_confirmation(&self) -> bool {
-        true
-    }
-
-    fn description(&self) -> String {
-        include_str!("./bash_tool/description.md").to_string()
-    }
-
-    fn icon(&self) -> IconName {
-        IconName::Terminal
-    }
-
-    fn input_schema(&self, format: LanguageModelToolSchemaFormat) -> serde_json::Value {
-        json_schema_for::<BashToolInput>(format)
-    }
-
-    fn ui_text(&self, input: &serde_json::Value) -> String {
-        match serde_json::from_value::<BashToolInput>(input.clone()) {
-            Ok(input) => {
-                let mut lines = input.command.lines();
-                let first_line = lines.next().unwrap_or_default();
-                let remaining_line_count = lines.count();
-                match remaining_line_count {
-                    0 => MarkdownString::inline_code(&first_line).0,
-                    1 => {
-                        MarkdownString::inline_code(&format!(
-                            "{} - {} more line",
-                            first_line, remaining_line_count
-                        ))
-                        .0
-                    }
-                    n => {
-                        MarkdownString::inline_code(&format!("{} - {} more lines", first_line, n)).0
-                    }
-                }
-            }
-            Err(_) => "Run bash command".to_string(),
-        }
-    }
-
-    fn run(
-        self: Arc<Self>,
-        input: serde_json::Value,
-        _messages: &[LanguageModelRequestMessage],
-        project: Entity<Project>,
-        _action_log: Entity<ActionLog>,
-        cx: &mut App,
-    ) -> Task<Result<String>> {
-        let input: BashToolInput = match serde_json::from_value(input) {
-            Ok(input) => input,
-            Err(err) => return Task::ready(Err(anyhow!(err))),
-        };
-
-        let project = project.read(cx);
-        let input_path = Path::new(&input.cd);
-        let working_dir = if input.cd == "." {
-            // Accept "." as meaning "the one worktree" if we only have one worktree.
-            let mut worktrees = project.worktrees(cx);
-
-            let only_worktree = match worktrees.next() {
-                Some(worktree) => worktree,
-                None => return Task::ready(Err(anyhow!("No worktrees found in the project"))),
-            };
-
-            if worktrees.next().is_some() {
-                return Task::ready(Err(anyhow!(
-                    "'.' is ambiguous in multi-root workspaces. Please specify a root directory explicitly."
-                )));
-            }
-
-            only_worktree.read(cx).abs_path()
-        } else if input_path.is_absolute() {
-            // Absolute paths are allowed, but only if they're in one of the project's worktrees.
-            if !project
-                .worktrees(cx)
-                .any(|worktree| input_path.starts_with(&worktree.read(cx).abs_path()))
-            {
-                return Task::ready(Err(anyhow!(
-                    "The absolute path must be within one of the project's worktrees"
-                )));
-            }
-
-            input_path.into()
-        } else {
-            let Some(worktree) = project.worktree_for_root_name(&input.cd, cx) else {
-                return Task::ready(Err(anyhow!(
-                    "`cd` directory {} not found in the project",
-                    &input.cd
-                )));
-            };
-
-            worktree.read(cx).abs_path()
-        };
-
-        cx.spawn(async move |_| {
-            // Add 2>&1 to merge stderr into stdout for proper interleaving.
-            let command = format!("({}) 2>&1", input.command);
-
-            let output = new_smol_command("bash")
-                .arg("-c")
-                .arg(&command)
-                .current_dir(working_dir)
-                .output()
-                .await
-                .context("Failed to execute bash command")?;
-
-            let output_string = String::from_utf8_lossy(&output.stdout).to_string();
-
-            if output.status.success() {
-                if output_string.is_empty() {
-                    Ok("Command executed successfully.".to_string())
-                } else {
-                    Ok(output_string)
-                }
-            } else {
-                Ok(format!(
-                    "Command failed with exit code {}\n{}",
-                    output.status.code().unwrap_or(-1),
-                    &output_string
-                ))
-            }
-        })
-    }
-}

crates/assistant_tools/src/bash_tool/description.md

@@ -1,7 +0,0 @@
-Executes a bash one-liner and returns the combined output.
-
-This tool spawns a bash process, combines stdout and stderr into one interleaved stream as they are produced (preserving the order of writes), and captures that stream into a string which is returned.
-
-Make sure you use the `cd` parameter to navigate to one of the root directories of the project. NEVER do it as part of the `command` itself, otherwise it will error.
-
-Remember that each invocation of this tool will spawn a new bash process, so you can't rely on any state from previous invocations.