wip

.cargo/config.toml

@@ -14,10 +14,10 @@ linker = "clang"
 rustflags = ["-C", "link-arg=-fuse-ld=mold"]
 
 [target.aarch64-apple-darwin]
-rustflags = ["-C", "link-args=-all_load"]
+rustflags = ["-C", "link-args=-Objc -all_load"]
 
 [target.x86_64-apple-darwin]
-rustflags = ["-C", "link-args=-all_load"]
+rustflags = ["-C", "link-args=-Objc -all_load"]
 
 [target.'cfg(target_os = "windows")']
 rustflags = [

.config/hakari.toml

@@ -1,43 +0,0 @@
-# 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/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 --config='profile.dev.debug="limited"'
+      run: cargo nextest run --workspace --no-fail-fast

.github/workflows/ci.yml

@@ -110,37 +110,6 @@ 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'
-    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";
-            false
-          }
-      - name: Check all crates depend on workspace-hack
-        run: |
-          cargo hakari manage-deps --dry-run || {
-            echo "To fix, run script/update-workspace-hack"
-            false
-          }
-
   style:
     timeout-minutes: 60
     name: Check formatting and spelling
@@ -240,6 +209,7 @@ jobs:
           cargo check -p workspace
           cargo build -p remote_server
           cargo check -p gpui --examples
+          script/check-rust-livekit-macos
 
       # Since the macOS runners are stateful, so we need to remove the config file to prevent potential bug.
       - name: Clean CI config file
@@ -463,7 +433,6 @@ jobs:
       - job_spec
       - style
       - migration_checks
-      - workspace_hack
       - linux_tests
       - build_remote_server
       - macos_tests
@@ -706,51 +675,6 @@ 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/community_release_actions.yml

@@ -59,9 +59,7 @@ jobs:
         if: steps.check-promotion-from-preview.outputs.was_promoted_from_preview == 'true'
         run: |
           TAG="${{ github.event.release.tag_name }}"
-          cat << 'EOF' > release_body.txt
-          ${{ github.event.release.body }}
-          EOF
+          echo \"${{ toJSON(github.event.release.body) }}\" > release_body.txt
           jq -n --arg tag "$TAG" --rawfile body release_body.txt '{version: $tag, markdown_body: $body}' \
             > release_data.json
           curl -X POST "https://zed.dev/api/send_release_notes_email" \

.github/workflows/release_nightly.yml

@@ -184,6 +184,9 @@ jobs:
           - os: arm Mac
             runner: [macOS, ARM64, test]
             install_nix: false
+          - os: arm Linux
+            runner: buildjet-16vcpu-ubuntu-2204-arm
+            install_nix: true
     if: github.repository_owner == 'zed-industries'
     runs-on: ${{ matrix.system.runner }}
     needs: tests
@@ -216,8 +219,7 @@ jobs:
           name: zed-industries
           authToken: "${{ secrets.CACHIX_AUTH_TOKEN }}"
       - run: nix build
-      - name: Limit /nix/store to 50GB
-        run: '[ $(du -sm /nix/store | cut -f1) -gt 50000 ] && nix-collect-garbage -d'
+      - run: 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

@@ -2,11 +2,11 @@
 resolver = "2"
 members = [
     "crates/activity_indicator",
-    "crates/agent",
     "crates/anthropic",
     "crates/askpass",
     "crates/assets",
     "crates/assistant",
+    "crates/assistant2",
     "crates/assistant_context_editor",
     "crates/assistant_eval",
     "crates/assistant_settings",
@@ -87,6 +87,7 @@ members = [
     "crates/languages",
     "crates/livekit_api",
     "crates/livekit_client",
+    "crates/livekit_client_macos",
     "crates/lmstudio",
     "crates/lsp",
     "crates/markdown",
@@ -192,14 +193,13 @@ members = [
     # Tooling
     #
 
-    "tooling/workspace-hack",
     "tooling/xtask",
 ]
 default-members = ["crates/zed"]
 
 [workspace.package]
 publish = false
-edition = "2024"
+edition = "2021"
 
 [workspace.dependencies]
 
@@ -208,12 +208,12 @@ edition = "2024"
 #
 
 activity_indicator = { path = "crates/activity_indicator" }
-agent = { path = "crates/agent" }
 ai = { path = "crates/ai" }
 anthropic = { path = "crates/anthropic" }
 askpass = { path = "crates/askpass" }
 assets = { path = "crates/assets" }
 assistant = { path = "crates/assistant" }
+assistant2 = { path = "crates/assistant2" }
 assistant_context_editor = { path = "crates/assistant_context_editor" }
 assistant_eval = { path = "crates/assistant_eval" }
 assistant_settings = { path = "crates/assistant_settings" }
@@ -292,6 +292,7 @@ language_tools = { path = "crates/language_tools" }
 languages = { path = "crates/languages" }
 livekit_api = { path = "crates/livekit_api" }
 livekit_client = { path = "crates/livekit_client" }
+livekit_client_macos = { path = "crates/livekit_client_macos" }
 lmstudio = { path = "crates/lmstudio" }
 lsp = { path = "crates/lsp" }
 markdown = { path = "crates/markdown" }
@@ -400,12 +401,8 @@ async-tungstenite = "0.28"
 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-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"] }
 base64 = "0.22"
@@ -423,9 +420,8 @@ circular-buffer = "1.0"
 clap = { version = "4.4", features = ["derive"] }
 cocoa = "0.26"
 cocoa-foundation = "0.2.0"
-core-video = { version = "0.4.3", features = ["metal"] }
 convert_case = "0.8.0"
-core-foundation = "0.10.0"
+core-foundation = "0.9.3"
 core-foundation-sys = "0.8.6"
 ctor = "0.4.0"
 dashmap = "6.0"
@@ -463,13 +459,17 @@ libc = "0.2"
 libsqlite3-sys = { version = "0.30.1", features = ["bundled"] }
 linkify = "0.10.0"
 linkme = "0.3.31"
+livekit = { git = "https://github.com/zed-industries/livekit-rust-sdks", rev = "811ceae29fabee455f110c56cd66b3f49a7e5003", features = [
+    "dispatcher",
+    "services-dispatcher",
+    "rustls-tls-native-roots",
+], default-features = false }
 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" }
 nix = "0.29"
-open = "5.0.0"
 num-format = "0.4.4"
 ordered-float = "2.1.1"
 palette = { version = "0.7.5", default-features = false, features = ["std"] }
@@ -512,7 +512,6 @@ rust-embed = { version = "8.4", features = ["include-exclude"] }
 rustc-hash = "2.1.0"
 rustls = { version = "0.23.22" }
 rustls-platform-verifier = "0.5.0"
-scap = { git = "https://github.com/zed-industries/scap", rev = "5715067104794aa356977c543e2f3e95c6183044", default-features = false }
 schemars = { version = "0.8", features = ["impl_json_schema", "indexmap2"] }
 semver = "1.0"
 serde = { version = "1.0", features = ["derive", "rc"] }
@@ -552,7 +551,6 @@ time = { version = "0.3", features = [
 tiny_http = "0.8"
 toml = "0.8"
 tokio = { version = "1" }
-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"
@@ -574,7 +572,7 @@ tree-sitter-md = { git = "https://github.com/tree-sitter-grammars/tree-sitter-ma
 tree-sitter-python = "0.23"
 tree-sitter-regex = "0.24"
 tree-sitter-ruby = "0.23"
-tree-sitter-rust = "0.24"
+tree-sitter-rust = "0.23"
 tree-sitter-typescript = "0.23"
 tree-sitter-yaml = { git = "https://github.com/zed-industries/tree-sitter-yaml", rev = "baff0b51c64ef6a1fb1f8390f3ad6015b83ec13a" }
 unicase = "2.6"
@@ -584,7 +582,6 @@ 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 = [
@@ -597,10 +594,9 @@ 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"
+metal = "0.31"
 
 [workspace.dependencies.async-stripe]
 git = "https://github.com/zed-industries/async-stripe"
@@ -665,14 +661,10 @@ features = [
 [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]
@@ -782,4 +774,4 @@ let_underscore_future = "allow"
 too_many_arguments = "allow"
 
 [workspace.metadata.cargo-machete]
-ignored = ["bindgen", "cbindgen", "prost_build", "serde", "component", "linkme", "workspace-hack"]
+ignored = ["bindgen", "cbindgen", "prost_build", "serde", "component", "linkme"]

Dockerfile-collab

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

assets/icons/arrow_down_right.svg

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

assets/icons/bug_off.svg

@@ -1 +0,0 @@
-<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/check_double.svg

@@ -1 +0,0 @@
-<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-check-check-icon lucide-check-check"><path d="M18 6 7 17l-5-5"/><path d="m22 10-7.5 7.5L13 16"/></svg>

assets/icons/circle_off.svg

@@ -1 +0,0 @@
-<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/debug_disabled_breakpoint.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" stroke="currentColor" fill="none" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-circle"><circle cx="12" cy="12" r="10"/></svg>

assets/icons/debug_disabled_log_breakpoint.svg

@@ -1 +0,0 @@
-<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-message-circle"><path d="M7.9 20A9 9 0 1 0 4 16.1L2 22Z"/></svg>

assets/icons/forward_arrow.svg

@@ -1 +0,0 @@
-<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/message_circle.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-message-circle-more"><path d="M7.9 20A9 9 0 1 0 4 16.1L2 22Z"/><path d="M8 12h.01"/><path d="M12 12h.01"/><path d="M16 12h.01"/></svg>

assets/icons/power.svg

@@ -1 +0,0 @@
-<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/user_round_pen.svg

@@ -1 +0,0 @@
-<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-user-round-pen-icon lucide-user-round-pen"><path d="M2 21a8 8 0 0 1 10.821-7.487"/><path d="M21.378 16.626a1 1 0 0 0-3.004-3.004l-4.01 4.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z"/><circle cx="10" cy="8" r="5"/></svg>

assets/icons/zed_assistant_2.svg

@@ -0,0 +1,5 @@
+<svg width="14" height="14" viewBox="0 0 14 14" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M5.27772 1.38585L4.39187 4.07909C4.34653 4.21692 4.26946 4.34219 4.16685 4.44479C4.06425 4.5474 3.93898 4.62447 3.80115 4.66981L1.10791 5.55566L3.80115 6.44151C3.93898 6.48685 4.06425 6.56392 4.16685 6.66653C4.26946 6.76913 4.34653 6.8944 4.39187 7.03223L5.27772 9.72547L6.16357 7.03223C6.20891 6.8944 6.28598 6.76913 6.38859 6.66653C6.49119 6.56392 6.61646 6.48685 6.7543 6.44151L9.44753 5.55566L6.7543 4.66981C6.61646 4.62447 6.49119 4.5474 6.38859 4.44479C6.28598 4.34219 6.20891 4.21692 6.16357 4.07909L5.27772 1.38585Z" fill="black" fill-opacity="0.15" stroke="black" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M8.35938 12.3555C8.35938 12.0664 8.52734 11.8086 9.00781 11.3594L10.2031 10.2344C10.6094 9.85156 10.7891 9.60156 10.7891 9.34375C10.7891 9.05469 10.5781 8.85938 10.2734 8.85938C10.0391 8.85938 9.87109 8.95312 9.66406 9.21094C9.42578 9.50781 9.25391 9.60938 8.99219 9.60938C8.61719 9.60938 8.35156 9.35938 8.35156 9.01172C8.35156 8.25 9.26953 7.57812 10.3594 7.57812C11.4961 7.57812 12.3438 8.26172 12.3438 9.17969C12.3438 9.75391 12.0391 10.3008 11.418 10.8516L10.4961 11.6719V11.7344H11.8047C12.2578 11.7344 12.5391 11.9766 12.5391 12.3711C12.5391 12.7656 12.2656 13 11.8047 13H9.08203C8.65234 13 8.35938 12.7383 8.35938 12.3555Z" fill="black"/>
+<path d="M11.0834 1.38585V3.71918M9.91675 2.55248H12.2501" stroke="black" stroke-opacity="0.75" stroke-width="1.25" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

assets/keymaps/default-linux.json

@@ -126,6 +126,7 @@
       // "alt-v": ["editor::MovePageUp", { "center_cursor": true }],
       "ctrl-alt-space": "editor::ShowCharacterPalette",
       "ctrl-;": "editor::ToggleLineNumbers",
+      "ctrl-k ctrl-r": "git::Restore",
       "ctrl-'": "editor::ToggleSelectedDiffHunks",
       "ctrl-\"": "editor::ExpandAllDiffHunks",
       "ctrl-i": "editor::ShowSignatureHelp",
@@ -137,22 +138,6 @@
       "shift-f9": "editor::EditLogBreakpoint"
     }
   },
-  {
-    "context": "Editor && !agent_diff",
-    "bindings": {
-      "ctrl-k ctrl-r": "git::Restore",
-      "ctrl-alt-y": "git::ToggleStaged",
-      "alt-y": "git::StageAndNext",
-      "alt-shift-y": "git::UnstageAndNext"
-    }
-  },
-  {
-    "context": "AgentDiff",
-    "bindings": {
-      "ctrl-y": "agent::Keep",
-      "ctrl-k ctrl-r": "agent::Reject"
-    }
-  },
   {
     "context": "Editor && mode == full",
     "bindings": {
@@ -311,7 +296,6 @@
       "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",
@@ -398,6 +382,9 @@
       "ctrl-k v": "markdown::OpenPreviewToTheSide",
       "ctrl-shift-v": "markdown::OpenPreview",
       "ctrl-alt-shift-c": "editor::DisplayCursorNames",
+      "ctrl-alt-y": "git::ToggleStaged",
+      "alt-y": "git::StageAndNext",
+      "alt-shift-y": "git::UnstageAndNext",
       "alt-.": "editor::GoToHunk",
       "alt-,": "editor::GoToPreviousHunk"
     }
@@ -482,8 +469,6 @@
       "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" }],
     }
   },
   {
@@ -597,6 +582,13 @@
       "ctrl-:": "editor::ToggleInlayHints"
     }
   },
+  {
+    "context": "ProposedChangesEditor",
+    "bindings": {
+      "ctrl-shift-y": "editor::ApplyDiffHunk",
+      "ctrl-alt-a": "editor::ApplyAllDiffHunks"
+    }
+  },
   {
     "context": "Editor && jupyter && !ContextEditor",
     "bindings": {
@@ -621,34 +613,29 @@
     }
   },
   {
-    "context": "AgentPanel",
+    "context": "AssistantPanel2",
     "bindings": {
-      "ctrl-n": "agent::NewThread",
-      "new": "agent::NewThread",
-      "ctrl-alt-n": "agent::NewPromptEditor",
-      "ctrl-shift-h": "agent::OpenHistory",
-      "ctrl-alt-c": "agent::OpenConfiguration",
-      "ctrl-i": "agent::ToggleProfileSelector",
+      "ctrl-n": "assistant2::NewThread",
+      "new": "assistant2::NewThread",
+      "ctrl-shift-h": "assistant2::OpenHistory",
       "ctrl-alt-/": "assistant::ToggleModelSelector",
-      "ctrl-shift-a": "agent::ToggleContextPicker",
-      "ctrl-e": "agent::ChatMode",
-      "ctrl-alt-e": "agent::RemoveAllContext"
+      "ctrl-shift-a": "assistant2::ToggleContextPicker",
+      "ctrl-e": "assistant2::ChatMode",
+      "ctrl-alt-e": "assistant2::RemoveAllContext"
     }
   },
   {
-    "context": "AgentPanel && prompt_editor",
+    "context": "AssistantPanel2 && prompt_editor",
     "use_key_equivalents": true,
     "bindings": {
-      "cmd-n": "agent::NewPromptEditor",
-      "cmd-alt-t": "agent::NewThread"
+      "cmd-n": "assistant2::NewPromptEditor",
+      "cmd-alt-t": "assistant2::NewThread"
     }
   },
   {
     "context": "MessageEditor > Editor",
     "bindings": {
-      "enter": "agent::Chat",
-      "ctrl-i": "agent::ToggleProfileSelector",
-      "shift-ctrl-r": "agent::OpenAgentDiff"
+      "enter": "assistant2::Chat"
     }
   },
   {
@@ -660,30 +647,21 @@
       "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": {
-      "up": "agent::FocusUp",
-      "right": "agent::FocusRight",
-      "left": "agent::FocusLeft",
-      "down": "agent::FocusDown",
-      "backspace": "agent::RemoveFocusedContext",
-      "enter": "agent::AcceptSuggestedContext"
+      "up": "assistant2::FocusUp",
+      "right": "assistant2::FocusRight",
+      "left": "assistant2::FocusLeft",
+      "down": "assistant2::FocusDown",
+      "backspace": "assistant2::RemoveFocusedContext",
+      "enter": "assistant2::AcceptSuggestedContext"
     }
   },
   {
     "context": "ThreadHistory",
     "bindings": {
-      "backspace": "agent::RemoveSelectedThread"
+      "backspace": "assistant2::RemoveSelectedThread"
     }
   },
   {
@@ -691,7 +669,7 @@
     "bindings": {
       "ctrl-[": "assistant::CyclePreviousInlineAssist",
       "ctrl-]": "assistant::CycleNextInlineAssist",
-      "ctrl-alt-e": "agent::RemoveAllContext"
+      "ctrl-alt-e": "assistant2::RemoveAllContext"
     }
   },
   {

assets/keymaps/default-macos.json

@@ -147,6 +147,10 @@
       "ctrl-shift-v": ["editor::MovePageUp", { "center_cursor": true }],
       "ctrl-cmd-space": "editor::ShowCharacterPalette",
       "cmd-;": "editor::ToggleLineNumbers",
+      "cmd-alt-z": "git::Restore",
+      "cmd-alt-y": "git::ToggleStaged",
+      "cmd-y": "git::StageAndNext",
+      "cmd-shift-y": "git::UnstageAndNext",
       "cmd-'": "editor::ToggleSelectedDiffHunks",
       "cmd-\"": "editor::ExpandAllDiffHunks",
       "cmd-alt-g b": "editor::ToggleGitBlame",
@@ -227,24 +231,6 @@
       "ctrl-alt-enter": "repl::RunInPlace"
     }
   },
-  {
-    "context": "Editor && !agent_diff",
-    "use_key_equivalents": true,
-    "bindings": {
-      "cmd-alt-z": "git::Restore",
-      "cmd-alt-y": "git::ToggleStaged",
-      "cmd-y": "git::StageAndNext",
-      "cmd-shift-y": "git::UnstageAndNext"
-    }
-  },
-  {
-    "context": "AgentDiff",
-    "use_key_equivalents": true,
-    "bindings": {
-      "cmd-y": "agent::Keep",
-      "cmd-alt-z": "agent::Reject"
-    }
-  },
   {
     "context": "AssistantPanel",
     "use_key_equivalents": true,
@@ -277,35 +263,33 @@
     }
   },
   {
-    "context": "AgentPanel",
+    "context": "AssistantPanel2",
     "use_key_equivalents": true,
     "bindings": {
-      "cmd-n": "agent::NewThread",
-      "cmd-alt-n": "agent::NewPromptEditor",
-      "cmd-shift-h": "agent::OpenHistory",
-      "cmd-alt-c": "agent::OpenConfiguration",
-      "cmd-i": "agent::ToggleProfileSelector",
+      "cmd-n": "assistant2::NewThread",
+      "cmd-alt-p": "assistant2::NewPromptEditor",
+      "cmd-shift-h": "assistant2::OpenHistory",
       "cmd-alt-/": "assistant::ToggleModelSelector",
-      "cmd-shift-a": "agent::ToggleContextPicker",
-      "cmd-e": "agent::ChatMode",
-      "cmd-alt-e": "agent::RemoveAllContext"
+      "cmd-shift-a": "assistant2::ToggleContextPicker",
+      "cmd-e": "assistant2::ChatMode",
+      "cmd-alt-e": "assistant2::RemoveAllContext"
     }
   },
   {
-    "context": "AgentPanel && prompt_editor",
+    "context": "AssistantPanel2 && prompt_editor",
     "use_key_equivalents": true,
     "bindings": {
-      "cmd-n": "agent::NewPromptEditor",
-      "cmd-alt-t": "agent::NewThread"
+      "cmd-n": "assistant2::NewPromptEditor",
+      "cmd-alt-t": "assistant2::NewThread"
     }
   },
   {
     "context": "MessageEditor > Editor",
     "use_key_equivalents": true,
     "bindings": {
-      "enter": "agent::Chat",
-      "cmd-i": "agent::ToggleProfileSelector",
-      "shift-ctrl-r": "agent::OpenAgentDiff"
+      "enter": "assistant2::Chat",
+      "cmd-g d": "git::Diff",
+      "shift-escape": "git::ExpandCommitEditor"
     }
   },
   {
@@ -317,31 +301,22 @@
       "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,
     "bindings": {
-      "up": "agent::FocusUp",
-      "right": "agent::FocusRight",
-      "left": "agent::FocusLeft",
-      "down": "agent::FocusDown",
-      "backspace": "agent::RemoveFocusedContext",
-      "enter": "agent::AcceptSuggestedContext"
+      "up": "assistant2::FocusUp",
+      "right": "assistant2::FocusRight",
+      "left": "assistant2::FocusLeft",
+      "down": "assistant2::FocusDown",
+      "backspace": "assistant2::RemoveFocusedContext",
+      "enter": "assistant2::AcceptSuggestedContext"
     }
   },
   {
     "context": "ThreadHistory",
     "bindings": {
-      "backspace": "agent::RemoveSelectedThread"
+      "backspace": "assistant2::RemoveSelectedThread"
     }
   },
   {
@@ -430,8 +405,7 @@
       "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 w": ["pane::CloseAllItems", { "close_pinned": false }],
-      "cmd-k cmd-w": "workspace::CloseAllItemsAndPanes",
+      "cmd-k cmd-w": ["pane::CloseAllItems", { "close_pinned": false }],
       "cmd-f": "project_search::ToggleFocus",
       "cmd-g": "search::SelectNextMatch",
       "cmd-shift-g": "search::SelectPreviousMatch",
@@ -608,8 +582,6 @@
       "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
@@ -716,13 +688,21 @@
       "ctrl-:": "editor::ToggleInlayHints"
     }
   },
+  {
+    "context": "ProposedChangesEditor",
+    "use_key_equivalents": true,
+    "bindings": {
+      "cmd-shift-y": "editor::ApplyDiffHunk",
+      "cmd-shift-a": "editor::ApplyAllDiffHunks"
+    }
+  },
   {
     "context": "PromptEditor",
     "use_key_equivalents": true,
     "bindings": {
-      "cmd-shift-a": "agent::ToggleContextPicker",
+      "cmd-shift-a": "assistant2::ToggleContextPicker",
       "cmd-alt-/": "assistant::ToggleModelSelector",
-      "cmd-alt-e": "agent::RemoveAllContext",
+      "cmd-alt-e": "assistant2::RemoveAllContext",
       "ctrl-[": "assistant::CyclePreviousInlineAssist",
       "ctrl-]": "assistant::CycleNextInlineAssist"
     }

assets/keymaps/vim.json

@@ -227,8 +227,6 @@
       "g u": "vim::PushLowercase",
       "g shift-u": "vim::PushUppercase",
       "g ~": "vim::PushOppositeCase",
-      "g ?": "vim::PushRot13",
-      // "g ?": "vim::PushRot47",
       "\"": "vim::PushRegister",
       "g w": "vim::PushRewrap",
       "g q": "vim::PushRewrap",
@@ -260,10 +258,9 @@
       "u": "vim::ConvertToLowerCase",
       "shift-u": "vim::ConvertToUpperCase",
       "shift-o": "vim::OtherEnd",
-      "o": "vim::OtherEndRowAware",
+      "o": "vim::OtherEnd",
       "d": "vim::VisualDelete",
       "x": "vim::VisualDelete",
-      "delete": "vim::VisualDelete",
       "shift-d": "vim::VisualDeleteLine",
       "shift-x": "vim::VisualDeleteLine",
       "y": "vim::VisualYank",
@@ -300,8 +297,6 @@
       "g r": ["vim::Paste", { "preserve_clipboard": true }],
       "g c": "vim::ToggleComments",
       "g q": "vim::Rewrap",
-      "g ?": "vim::ConvertToRot13",
-      // "g ?": "vim::ConvertToRot47",
       "\"": "vim::PushRegister",
       // tree-sitter related commands
       "[ x": "editor::SelectLargerSyntaxNode",
@@ -335,106 +330,27 @@
     }
   },
   {
-    "context": "vim_mode == helix_normal && !menu",
+    "context": "vim_mode == helix_normal",
     "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",
-      "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",
-
-      "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"
+      "w": "vim::NextWordStart",
+      "e": "vim::NextWordEnd",
+      "b": "vim::PreviousWordStart",
+
+      "h": "vim::Left",
+      "j": "vim::Down",
+      "k": "vim::Up",
+      "l": "vim::Right"
     }
   },
+
   {
     "context": "vim_mode == insert && !(showing_code_actions || showing_completions)",
     "bindings": {
-      "ctrl-p": "editor::ShowWordCompletions",
-      "ctrl-n": "editor::ShowWordCompletions"
+      "ctrl-p": "editor::ShowCompletions",
+      "ctrl-n": "editor::ShowCompletions"
     }
   },
   {
@@ -560,13 +476,6 @@
       "~": "vim::CurrentLine"
     }
   },
-  {
-    "context": "vim_operator == g?",
-    "bindings": {
-      "g ?": "vim::CurrentLine",
-      "?": "vim::CurrentLine"
-    }
-  },
   {
     "context": "vim_operator == gq",
     "bindings": {

assets/prompts/assistant_system_prompt.hbs

@@ -1,37 +1,17 @@
-You are an AI assistant integrated into a code editor. You have the programming ability of an expert programmer who takes pride in writing high-quality code and is driven to the point of obsession about solving problems effectively. Your goal is to do one of the following two things:
+You are an AI assistant integrated into a text editor. Your goal is to do one of the following two things:
 
 1. Help users answer questions and perform tasks related to their codebase.
 2. Answer general-purpose questions unrelated to their particular codebase.
 
 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:
+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 clearly requests that you perform an action, carry out the action directly without explaining why you are doing so.
-
-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.
+- The editing actions you perform might produce 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.
 - 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.
 
-Tool use:
-- Make sure to adhere to the tools schema.
-- Provide every required argument.
-- DO NOT use tools to access items that are already available in the context section.
-- Use only the tools that are currently available.
-- DO NOT use a tool that is not available just because it appears in the conversation. This means the user turned it off.
-
-Responding:
-- Be concise and direct in your responses.
-- Never apologize or thank the user.
-- Don't comment that you have just realized or understood something.
-- When you are going to make a tool call, tersely explain your reasoning for choosing to use that tool, with no flourishes or commentary beyond that information.
-    For example, rather than saying "You're absolutely right! Thank you for providing that context. Now I understand that we're missing a dependency, and I need to add it:" say "I'll add that missing dependency:" instead.
-- Also, don't restate what a tool call is about to do (or just did).
-    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.
+Be concise and direct in your responses.
 
 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:
 

assets/settings/default.json

@@ -115,15 +115,6 @@
   "confirm_quit": false,
   // Whether to restore last closed project when fresh Zed instance is opened.
   "restore_on_startup": "last_session",
-  // Whether to attempt to restore previous file's state when opening it again.
-  // The state is stored per pane.
-  // When disabled, defaults are applied instead of the state restoration.
-  //
-  // E.g. for editors, selections, folds and scroll positions are restored, if the same file is closed and, later, opened again in the same pane.
-  // When disabled, a single selection in the very beginning of the file, zero scroll position and no folds state is used as a default.
-  //
-  // Default: true
-  "restore_on_file_reopen": true,
   // Size of the drop target in the editor.
   "drop_target_size": 0.2,
   // Whether the window should be closed when using 'close active item' on a window with no tabs.
@@ -164,8 +155,8 @@
   //
   // Default: not set, defaults to "bar"
   "cursor_shape": null,
-  // Determines when the mouse cursor should be hidden in an editor or input box.
-  "hide_mouse": "on_typing_and_movement",
+  // Determines whether the mouse cursor is hidden when typing in an editor or input box.
+  "hide_mouse_while_typing": true,
   // How to highlight the current line in the editor.
   //
   // 1. Don't highlight the current line:
@@ -633,56 +624,43 @@
       // The model to use.
       "model": "claude-3-5-sonnet-latest"
     },
-    // When enabled, the agent can run potentially destructive actions without asking for your confirmation.
-    "always_allow_tool_actions": false,
-    "default_profile": "write",
+    "default_profile": "code-writer",
     "profiles": {
-      "ask": {
-        "name": "Ask",
-        // We don't know which of the context server tools are safe for the "Ask" profile, so we don't enable them by default.
-        // "enable_all_context_servers": true,
+      "read-only": {
+        "name": "Read-only",
         "tools": {
           "diagnostics": true,
           "fetch": true,
-          "list_directory": false,
+          "list-directory": true,
           "now": true,
-          "path_search": true,
-          "read_file": true,
-          "regex_search": true,
+          "path-search": true,
+          "read-file": true,
+          "regex-search": true,
           "thinking": true
         }
       },
-      "write": {
-        "name": "Write",
-        "enable_all_context_servers": true,
+      "code-writer": {
+        "name": "Code Writer",
         "tools": {
           "bash": true,
-          "batch_tool": true,
-          "code_symbols": true,
-          "copy_path": false,
-          "create_file": true,
-          "delete_path": false,
+          "copy-path": true,
+          "create-file": true,
+          "delete-path": true,
           "diagnostics": true,
-          "find_replace_file": true,
+          "find-replace-file": true,
+          "edit-files": false,
           "fetch": true,
-          "list_directory": false,
-          "move_path": false,
+          "list-directory": true,
+          "move-path": true,
           "now": true,
-          "path_search": true,
-          "read_file": true,
-          "regex_search": true,
-          "symbol_info": true,
+          "path-search": true,
+          "read-file": true,
+          "regex-search": true,
           "thinking": true
         }
       }
     },
-    // Where to show notifications when an agent has either completed
-    // its response, or else needs confirmation before it can run a
-    // tool action.
-    // "primary_screen" - Show the notification only on your primary screen (default)
-    // "all_screens" - Show these notifications on all screens
-    // "never" - Never show these notifications
-    "notify_when_agent_waiting": "primary_screen"
+    "notify_when_agent_waiting": true
   },
   // The settings for slash commands.
   "slash_commands": {
@@ -1200,27 +1178,7 @@
     // When set to 0, waits indefinitely.
     //
     // Default: 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"
+    "lsp_fetch_timeout_ms": 0
   },
   // Different settings for specific languages.
   "languages": {
@@ -1506,6 +1464,11 @@
   "dev": {
     // "theme": "Andromeda"
   },
+  // Task-related settings.
+  "task": {
+    // Whether to show task status indicator in the status bar. Default: true
+    "show_status_indicator": true
+  },
   // Whether to show full labels in line indicator or short ones
   //
   // Values:

assets/settings/initial_tasks.json

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

crates/activity_indicator/Cargo.toml

@@ -25,7 +25,6 @@ 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

@@ -3,20 +3,20 @@ use editor::Editor;
 use extension_host::ExtensionStore;
 use futures::StreamExt;
 use gpui::{
-    Animation, AnimationExt as _, App, Context, CursorStyle, Entity, EventEmitter,
-    InteractiveElement as _, ParentElement as _, Render, SharedString, StatefulInteractiveElement,
-    Styled, Transformation, Window, actions, percentage,
+    actions, percentage, Animation, AnimationExt as _, App, Context, CursorStyle, Entity,
+    EventEmitter, InteractiveElement as _, ParentElement as _, Render, SharedString,
+    StatefulInteractiveElement, Styled, Transformation, Window,
 };
 use language::{BinaryStatus, LanguageRegistry, LanguageServerId};
 use project::{
     EnvironmentErrorMessage, LanguageServerProgress, LspStoreEvent, Project,
-    ProjectEnvironmentEvent,
+    ProjectEnvironmentEvent, WorktreeId,
 };
 use smallvec::SmallVec;
-use std::{cmp::Reverse, fmt::Write, path::Path, sync::Arc, time::Duration};
-use ui::{ButtonLike, ContextMenu, PopoverMenu, PopoverMenuHandle, Tooltip, prelude::*};
+use std::{cmp::Reverse, fmt::Write, sync::Arc, time::Duration};
+use ui::{prelude::*, ButtonLike, ContextMenu, PopoverMenu, PopoverMenuHandle, Tooltip};
 use util::truncate_and_trailoff;
-use workspace::{StatusItemView, Workspace, item::ItemHandle};
+use workspace::{item::ItemHandle, StatusItemView, Workspace};
 
 actions!(activity_indicator, [ShowErrorMessage]);
 
@@ -218,14 +218,13 @@ impl ActivityIndicator {
     fn pending_environment_errors<'a>(
         &'a self,
         cx: &'a App,
-    ) -> impl Iterator<Item = (&'a Arc<Path>, &'a EnvironmentErrorMessage)> {
+    ) -> impl Iterator<Item = (&'a WorktreeId, &'a EnvironmentErrorMessage)> {
         self.project.read(cx).shell_environment_errors(cx)
     }
 
     fn content_to_render(&mut self, cx: &mut Context<Self>) -> Option<Content> {
         // Show if any direnv calls failed
-        if let Some((abs_path, error)) = self.pending_environment_errors(cx).next() {
-            let abs_path = abs_path.clone();
+        if let Some((&worktree_id, error)) = self.pending_environment_errors(cx).next() {
             return Some(Content {
                 icon: Some(
                     Icon::new(IconName::Warning)
@@ -235,7 +234,7 @@ impl ActivityIndicator {
                 message: error.0.clone(),
                 on_click: Some(Arc::new(move |this, window, cx| {
                     this.project.update(cx, |project, cx| {
-                        project.remove_environment_error(&abs_path, cx);
+                        project.remove_environment_error(worktree_id, cx);
                     });
                     window.dispatch_action(Box::new(workspace::OpenLog), cx);
                 })),

crates/agent/src/assistant_configuration/manage_profiles_modal.rs

@@ -1,570 +0,0 @@
-mod profile_modal_header;
-
-use std::sync::Arc;
-
-use assistant_settings::{AgentProfile, AgentProfileId, AssistantSettings};
-use assistant_tool::ToolWorkingSet;
-use convert_case::{Case, Casing as _};
-use editor::Editor;
-use fs::Fs;
-use gpui::{
-    DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, Subscription, WeakEntity,
-    prelude::*,
-};
-use settings::{Settings as _, update_settings_file};
-use ui::{
-    KeyBinding, ListItem, ListItemSpacing, ListSeparator, Navigable, NavigableEntry, prelude::*,
-};
-use util::ResultExt as _;
-use workspace::{ModalView, Workspace};
-
-use crate::assistant_configuration::manage_profiles_modal::profile_modal_header::ProfileModalHeader;
-use crate::assistant_configuration::tool_picker::{ToolPicker, ToolPickerDelegate};
-use crate::{AssistantPanel, ManageProfiles, ThreadStore};
-
-enum Mode {
-    ChooseProfile(ChooseProfileMode),
-    NewProfile(NewProfileMode),
-    ViewProfile(ViewProfileMode),
-    ConfigureTools {
-        profile_id: AgentProfileId,
-        tool_picker: Entity<ToolPicker>,
-        _subscription: Subscription,
-    },
-}
-
-impl Mode {
-    pub fn choose_profile(_window: &mut Window, cx: &mut Context<ManageProfilesModal>) -> Self {
-        let settings = AssistantSettings::get_global(cx);
-
-        let mut profiles = settings.profiles.clone();
-        profiles.sort_unstable_by(|_, a, _, b| a.name.cmp(&b.name));
-
-        let profiles = profiles
-            .into_iter()
-            .map(|(id, profile)| ProfileEntry {
-                id,
-                name: profile.name,
-                navigation: NavigableEntry::focusable(cx),
-            })
-            .collect::<Vec<_>>();
-
-        Self::ChooseProfile(ChooseProfileMode {
-            profiles,
-            add_new_profile: NavigableEntry::focusable(cx),
-        })
-    }
-}
-
-#[derive(Clone)]
-struct ProfileEntry {
-    pub id: AgentProfileId,
-    pub name: SharedString,
-    pub navigation: NavigableEntry,
-}
-
-#[derive(Clone)]
-pub struct ChooseProfileMode {
-    profiles: Vec<ProfileEntry>,
-    add_new_profile: NavigableEntry,
-}
-
-#[derive(Clone)]
-pub struct ViewProfileMode {
-    profile_id: AgentProfileId,
-    fork_profile: NavigableEntry,
-    configure_tools: NavigableEntry,
-}
-
-#[derive(Clone)]
-pub struct NewProfileMode {
-    name_editor: Entity<Editor>,
-    base_profile_id: Option<AgentProfileId>,
-}
-
-pub struct ManageProfilesModal {
-    fs: Arc<dyn Fs>,
-    tools: Arc<ToolWorkingSet>,
-    thread_store: WeakEntity<ThreadStore>,
-    focus_handle: FocusHandle,
-    mode: Mode,
-}
-
-impl ManageProfilesModal {
-    pub fn register(
-        workspace: &mut Workspace,
-        _window: Option<&mut Window>,
-        _cx: &mut Context<Workspace>,
-    ) {
-        workspace.register_action(|workspace, action: &ManageProfiles, window, cx| {
-            if let Some(panel) = workspace.panel::<AssistantPanel>(cx) {
-                let fs = workspace.app_state().fs.clone();
-                let thread_store = panel.read(cx).thread_store();
-                let tools = thread_store.read(cx).tools();
-                let thread_store = thread_store.downgrade();
-                workspace.toggle_modal(window, cx, |window, cx| {
-                    let mut this = Self::new(fs, tools, thread_store, window, cx);
-
-                    if let Some(profile_id) = action.customize_tools.clone() {
-                        this.configure_tools(profile_id, window, cx);
-                    }
-
-                    this
-                })
-            }
-        });
-    }
-
-    pub fn new(
-        fs: Arc<dyn Fs>,
-        tools: Arc<ToolWorkingSet>,
-        thread_store: WeakEntity<ThreadStore>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Self {
-        let focus_handle = cx.focus_handle();
-
-        Self {
-            fs,
-            tools,
-            thread_store,
-            focus_handle,
-            mode: Mode::choose_profile(window, cx),
-        }
-    }
-
-    fn choose_profile(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        self.mode = Mode::choose_profile(window, cx);
-        self.focus_handle(cx).focus(window);
-    }
-
-    fn new_profile(
-        &mut self,
-        base_profile_id: Option<AgentProfileId>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        let name_editor = cx.new(|cx| Editor::single_line(window, cx));
-        name_editor.update(cx, |editor, cx| {
-            editor.set_placeholder_text("Profile name", cx);
-        });
-
-        self.mode = Mode::NewProfile(NewProfileMode {
-            name_editor,
-            base_profile_id,
-        });
-        self.focus_handle(cx).focus(window);
-    }
-
-    pub fn view_profile(
-        &mut self,
-        profile_id: AgentProfileId,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        self.mode = Mode::ViewProfile(ViewProfileMode {
-            profile_id,
-            fork_profile: NavigableEntry::focusable(cx),
-            configure_tools: NavigableEntry::focusable(cx),
-        });
-        self.focus_handle(cx).focus(window);
-    }
-
-    fn configure_tools(
-        &mut self,
-        profile_id: AgentProfileId,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        let settings = AssistantSettings::get_global(cx);
-        let Some(profile) = settings.profiles.get(&profile_id).cloned() else {
-            return;
-        };
-
-        let tool_picker = cx.new(|cx| {
-            let delegate = ToolPickerDelegate::new(
-                self.fs.clone(),
-                self.tools.clone(),
-                self.thread_store.clone(),
-                profile_id.clone(),
-                profile,
-                cx,
-            );
-            ToolPicker::new(delegate, window, cx)
-        });
-        let dismiss_subscription = cx.subscribe_in(&tool_picker, window, {
-            let profile_id = profile_id.clone();
-            move |this, _tool_picker, _: &DismissEvent, window, cx| {
-                this.view_profile(profile_id.clone(), window, cx);
-            }
-        });
-
-        self.mode = Mode::ConfigureTools {
-            profile_id,
-            tool_picker,
-            _subscription: dismiss_subscription,
-        };
-        self.focus_handle(cx).focus(window);
-    }
-
-    fn confirm(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        match &self.mode {
-            Mode::ChooseProfile { .. } => {}
-            Mode::NewProfile(mode) => {
-                let settings = AssistantSettings::get_global(cx);
-
-                let base_profile = mode
-                    .base_profile_id
-                    .as_ref()
-                    .and_then(|profile_id| settings.profiles.get(profile_id).cloned());
-
-                let name = mode.name_editor.read(cx).text(cx);
-                let profile_id = AgentProfileId(name.to_case(Case::Kebab).into());
-
-                let profile = AgentProfile {
-                    name: name.into(),
-                    tools: base_profile
-                        .as_ref()
-                        .map(|profile| profile.tools.clone())
-                        .unwrap_or_default(),
-                    enable_all_context_servers: base_profile
-                        .as_ref()
-                        .map(|profile| profile.enable_all_context_servers)
-                        .unwrap_or_default(),
-                    context_servers: base_profile
-                        .map(|profile| profile.context_servers)
-                        .unwrap_or_default(),
-                };
-
-                self.create_profile(profile_id.clone(), profile, cx);
-                self.view_profile(profile_id, window, cx);
-            }
-            Mode::ViewProfile(_) => {}
-            Mode::ConfigureTools { .. } => {}
-        }
-    }
-
-    fn cancel(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        match &self.mode {
-            Mode::ChooseProfile { .. } => {
-                cx.emit(DismissEvent);
-            }
-            Mode::NewProfile(mode) => {
-                if let Some(profile_id) = mode.base_profile_id.clone() {
-                    self.view_profile(profile_id, window, cx);
-                } else {
-                    self.choose_profile(window, cx);
-                }
-            }
-            Mode::ViewProfile(_) => self.choose_profile(window, cx),
-            Mode::ConfigureTools { .. } => {}
-        }
-    }
-
-    fn create_profile(
-        &self,
-        profile_id: AgentProfileId,
-        profile: AgentProfile,
-        cx: &mut Context<Self>,
-    ) {
-        update_settings_file::<AssistantSettings>(self.fs.clone(), cx, {
-            move |settings, _cx| {
-                settings.create_profile(profile_id, profile).log_err();
-            }
-        });
-    }
-}
-
-impl ModalView for ManageProfilesModal {}
-
-impl Focusable for ManageProfilesModal {
-    fn focus_handle(&self, cx: &App) -> FocusHandle {
-        match &self.mode {
-            Mode::ChooseProfile(_) => self.focus_handle.clone(),
-            Mode::NewProfile(mode) => mode.name_editor.focus_handle(cx),
-            Mode::ViewProfile(_) => self.focus_handle.clone(),
-            Mode::ConfigureTools { tool_picker, .. } => tool_picker.focus_handle(cx),
-        }
-    }
-}
-
-impl EventEmitter<DismissEvent> for ManageProfilesModal {}
-
-impl ManageProfilesModal {
-    fn render_choose_profile(
-        &mut self,
-        mode: ChooseProfileMode,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> impl IntoElement {
-        Navigable::new(
-            div()
-                .track_focus(&self.focus_handle(cx))
-                .size_full()
-                .child(ProfileModalHeader::new(
-                    "Agent Profiles",
-                    IconName::ZedAssistant,
-                ))
-                .child(
-                    v_flex()
-                        .pb_1()
-                        .child(ListSeparator)
-                        .children(mode.profiles.iter().map(|profile| {
-                            div()
-                                .id(SharedString::from(format!("profile-{}", profile.id)))
-                                .track_focus(&profile.navigation.focus_handle)
-                                .on_action({
-                                    let profile_id = profile.id.clone();
-                                    cx.listener(move |this, _: &menu::Confirm, window, cx| {
-                                        this.view_profile(profile_id.clone(), window, cx);
-                                    })
-                                })
-                                .child(
-                                    ListItem::new(SharedString::from(format!(
-                                        "profile-{}",
-                                        profile.id
-                                    )))
-                                    .toggle_state(
-                                        profile
-                                            .navigation
-                                            .focus_handle
-                                            .contains_focused(window, cx),
-                                    )
-                                    .inset(true)
-                                    .spacing(ListItemSpacing::Sparse)
-                                    .child(Label::new(profile.name.clone()))
-                                    .end_slot(
-                                        h_flex()
-                                            .gap_1()
-                                            .child(Label::new("Customize").size(LabelSize::Small))
-                                            .children(KeyBinding::for_action_in(
-                                                &menu::Confirm,
-                                                &self.focus_handle,
-                                                window,
-                                                cx,
-                                            )),
-                                    )
-                                    .on_click({
-                                        let profile_id = profile.id.clone();
-                                        cx.listener(move |this, _, window, cx| {
-                                            this.view_profile(profile_id.clone(), window, cx);
-                                        })
-                                    }),
-                                )
-                        }))
-                        .child(ListSeparator)
-                        .child(
-                            div()
-                                .id("new-profile")
-                                .track_focus(&mode.add_new_profile.focus_handle)
-                                .on_action(cx.listener(|this, _: &menu::Confirm, window, cx| {
-                                    this.new_profile(None, window, cx);
-                                }))
-                                .child(
-                                    ListItem::new("new-profile")
-                                        .toggle_state(
-                                            mode.add_new_profile
-                                                .focus_handle
-                                                .contains_focused(window, cx),
-                                        )
-                                        .inset(true)
-                                        .spacing(ListItemSpacing::Sparse)
-                                        .start_slot(Icon::new(IconName::Plus))
-                                        .child(Label::new("Add New Profile"))
-                                        .on_click({
-                                            cx.listener(move |this, _, window, cx| {
-                                                this.new_profile(None, window, cx);
-                                            })
-                                        }),
-                                ),
-                        ),
-                )
-                .into_any_element(),
-        )
-        .map(|mut navigable| {
-            for profile in mode.profiles {
-                navigable = navigable.entry(profile.navigation);
-            }
-
-            navigable
-        })
-        .entry(mode.add_new_profile)
-    }
-
-    fn render_new_profile(
-        &mut self,
-        mode: NewProfileMode,
-        _window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> impl IntoElement {
-        let settings = AssistantSettings::get_global(cx);
-
-        let base_profile_name = mode.base_profile_id.as_ref().map(|base_profile_id| {
-            settings
-                .profiles
-                .get(base_profile_id)
-                .map(|profile| profile.name.clone())
-                .unwrap_or_else(|| "Unknown".into())
-        });
-
-        v_flex()
-            .id("new-profile")
-            .track_focus(&self.focus_handle(cx))
-            .child(ProfileModalHeader::new(
-                match base_profile_name {
-                    Some(base_profile) => format!("Fork {base_profile}"),
-                    None => "New Profile".into(),
-                },
-                IconName::Plus,
-            ))
-            .child(ListSeparator)
-            .child(h_flex().p_2().child(mode.name_editor.clone()))
-    }
-
-    fn render_view_profile(
-        &mut self,
-        mode: ViewProfileMode,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> impl IntoElement {
-        let settings = AssistantSettings::get_global(cx);
-
-        let profile_name = settings
-            .profiles
-            .get(&mode.profile_id)
-            .map(|profile| profile.name.clone())
-            .unwrap_or_else(|| "Unknown".into());
-
-        Navigable::new(
-            div()
-                .track_focus(&self.focus_handle(cx))
-                .size_full()
-                .child(ProfileModalHeader::new(
-                    profile_name,
-                    IconName::ZedAssistant,
-                ))
-                .child(
-                    v_flex()
-                        .pb_1()
-                        .child(ListSeparator)
-                        .child(
-                            div()
-                                .id("fork-profile")
-                                .track_focus(&mode.fork_profile.focus_handle)
-                                .on_action({
-                                    let profile_id = mode.profile_id.clone();
-                                    cx.listener(move |this, _: &menu::Confirm, window, cx| {
-                                        this.new_profile(Some(profile_id.clone()), window, cx);
-                                    })
-                                })
-                                .child(
-                                    ListItem::new("fork-profile")
-                                        .toggle_state(
-                                            mode.fork_profile
-                                                .focus_handle
-                                                .contains_focused(window, cx),
-                                        )
-                                        .inset(true)
-                                        .spacing(ListItemSpacing::Sparse)
-                                        .start_slot(Icon::new(IconName::GitBranch))
-                                        .child(Label::new("Fork Profile"))
-                                        .on_click({
-                                            let profile_id = mode.profile_id.clone();
-                                            cx.listener(move |this, _, window, cx| {
-                                                this.new_profile(
-                                                    Some(profile_id.clone()),
-                                                    window,
-                                                    cx,
-                                                );
-                                            })
-                                        }),
-                                ),
-                        )
-                        .child(
-                            div()
-                                .id("configure-tools")
-                                .track_focus(&mode.configure_tools.focus_handle)
-                                .on_action({
-                                    let profile_id = mode.profile_id.clone();
-                                    cx.listener(move |this, _: &menu::Confirm, window, cx| {
-                                        this.configure_tools(profile_id.clone(), window, cx);
-                                    })
-                                })
-                                .child(
-                                    ListItem::new("configure-tools")
-                                        .toggle_state(
-                                            mode.configure_tools
-                                                .focus_handle
-                                                .contains_focused(window, cx),
-                                        )
-                                        .inset(true)
-                                        .spacing(ListItemSpacing::Sparse)
-                                        .start_slot(Icon::new(IconName::Cog))
-                                        .child(Label::new("Configure Tools"))
-                                        .on_click({
-                                            let profile_id = mode.profile_id.clone();
-                                            cx.listener(move |this, _, window, cx| {
-                                                this.configure_tools(
-                                                    profile_id.clone(),
-                                                    window,
-                                                    cx,
-                                                );
-                                            })
-                                        }),
-                                ),
-                        ),
-                )
-                .into_any_element(),
-        )
-        .entry(mode.fork_profile)
-        .entry(mode.configure_tools)
-    }
-}
-
-impl Render for ManageProfilesModal {
-    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let settings = AssistantSettings::get_global(cx);
-
-        div()
-            .elevation_3(cx)
-            .w(rems(34.))
-            .key_context("ManageProfilesModal")
-            .on_action(cx.listener(|this, _: &menu::Cancel, window, cx| this.cancel(window, cx)))
-            .on_action(cx.listener(|this, _: &menu::Confirm, window, cx| this.confirm(window, cx)))
-            .capture_any_mouse_down(cx.listener(|this, _, window, cx| {
-                this.focus_handle(cx).focus(window);
-            }))
-            .on_mouse_down_out(cx.listener(|_this, _, _, cx| cx.emit(DismissEvent)))
-            .child(match &self.mode {
-                Mode::ChooseProfile(mode) => self
-                    .render_choose_profile(mode.clone(), window, cx)
-                    .into_any_element(),
-                Mode::NewProfile(mode) => self
-                    .render_new_profile(mode.clone(), window, cx)
-                    .into_any_element(),
-                Mode::ViewProfile(mode) => self
-                    .render_view_profile(mode.clone(), window, cx)
-                    .into_any_element(),
-                Mode::ConfigureTools {
-                    profile_id,
-                    tool_picker,
-                    ..
-                } => {
-                    let profile_name = settings
-                        .profiles
-                        .get(profile_id)
-                        .map(|profile| profile.name.clone())
-                        .unwrap_or_else(|| "Unknown".into());
-
-                    div()
-                        .child(ProfileModalHeader::new(
-                            format!("{profile_name}: Configure Tools"),
-                            IconName::Cog,
-                        ))
-                        .child(ListSeparator)
-                        .child(tool_picker.clone())
-                        .into_any_element()
-                }
-            })
-    }
-}

crates/agent/src/assistant_configuration/manage_profiles_modal/profile_modal_header.rs

@@ -1,38 +0,0 @@
-use ui::prelude::*;
-
-#[derive(IntoElement)]
-pub struct ProfileModalHeader {
-    label: SharedString,
-    icon: IconName,
-}
-
-impl ProfileModalHeader {
-    pub fn new(label: impl Into<SharedString>, icon: IconName) -> Self {
-        Self {
-            label: label.into(),
-            icon,
-        }
-    }
-}
-
-impl RenderOnce for ProfileModalHeader {
-    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
-        h_flex()
-            .w_full()
-            .px(DynamicSpacing::Base12.rems(cx))
-            .pt(DynamicSpacing::Base08.rems(cx))
-            .pb(DynamicSpacing::Base04.rems(cx))
-            .rounded_t_sm()
-            .gap_1p5()
-            .child(Icon::new(self.icon).size(IconSize::XSmall))
-            .child(
-                h_flex().gap_1().overflow_x_hidden().child(
-                    div()
-                        .max_w_96()
-                        .overflow_x_hidden()
-                        .text_ellipsis()
-                        .child(Headline::new(self.label).size(HeadlineSize::XSmall)),
-                ),
-            )
-    }
-}

crates/agent/src/context.rs

@@ -1,244 +0,0 @@
-use std::{ops::Range, sync::Arc};
-
-use gpui::{App, Entity, SharedString};
-use language::{Buffer, File};
-use language_model::LanguageModelRequestMessage;
-use project::ProjectPath;
-use serde::{Deserialize, Serialize};
-use text::{Anchor, BufferId};
-use ui::IconName;
-use util::post_inc;
-
-use crate::thread::Thread;
-
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, Serialize, Deserialize)]
-pub struct ContextId(pub(crate) usize);
-
-impl ContextId {
-    pub fn post_inc(&mut self) -> Self {
-        Self(post_inc(&mut self.0))
-    }
-}
-pub enum ContextKind {
-    File,
-    Directory,
-    Symbol,
-    FetchedUrl,
-    Thread,
-}
-
-impl ContextKind {
-    pub fn icon(&self) -> IconName {
-        match self {
-            ContextKind::File => IconName::File,
-            ContextKind::Directory => IconName::Folder,
-            ContextKind::Symbol => IconName::Code,
-            ContextKind::FetchedUrl => IconName::Globe,
-            ContextKind::Thread => IconName::MessageBubbles,
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub enum AssistantContext {
-    File(FileContext),
-    Directory(DirectoryContext),
-    Symbol(SymbolContext),
-    FetchedUrl(FetchedUrlContext),
-    Thread(ThreadContext),
-}
-
-impl AssistantContext {
-    pub fn id(&self) -> ContextId {
-        match self {
-            Self::File(file) => file.id,
-            Self::Directory(directory) => directory.id,
-            Self::Symbol(symbol) => symbol.id,
-            Self::FetchedUrl(url) => url.id,
-            Self::Thread(thread) => thread.id,
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct FileContext {
-    pub id: ContextId,
-    pub context_buffer: ContextBuffer,
-}
-
-#[derive(Debug, Clone)]
-pub struct DirectoryContext {
-    pub id: ContextId,
-    pub project_path: ProjectPath,
-    pub context_buffers: Vec<ContextBuffer>,
-}
-
-#[derive(Debug, Clone)]
-pub struct SymbolContext {
-    pub id: ContextId,
-    pub context_symbol: ContextSymbol,
-}
-
-#[derive(Debug, Clone)]
-pub struct FetchedUrlContext {
-    pub id: ContextId,
-    pub url: SharedString,
-    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,
-    pub thread: Entity<Thread>,
-    pub text: SharedString,
-}
-
-impl ThreadContext {
-    pub fn summary(&self, cx: &App) -> SharedString {
-        self.thread
-            .read(cx)
-            .summary()
-            .unwrap_or("New thread".into())
-    }
-}
-
-// 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,
-    pub buffer: Entity<Buffer>,
-    pub file: Arc<dyn File>,
-    pub version: clock::Global,
-    pub text: SharedString,
-}
-
-impl std::fmt::Debug for ContextBuffer {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("ContextBuffer")
-            .field("id", &self.id)
-            .field("buffer", &self.buffer)
-            .field("version", &self.version)
-            .field("text", &self.text)
-            .finish()
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct ContextSymbol {
-    pub id: ContextSymbolId,
-    pub buffer: Entity<Buffer>,
-    pub buffer_version: clock::Global,
-    /// The range that the symbol encloses, e.g. for function symbol, this will
-    /// include not only the signature, but also the body
-    pub enclosing_range: Range<Anchor>,
-    pub text: SharedString,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ContextSymbolId {
-    pub path: ProjectPath,
-    pub name: SharedString,
-    pub range: Range<Anchor>,
-}
-
-/// 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();
-    let mut fetch_context = Vec::new();
-    let mut thread_context = Vec::new();
-
-    for context in contexts {
-        match context {
-            AssistantContext::File(context) => file_context.push(context),
-            AssistantContext::Directory(context) => directory_context.push(context),
-            AssistantContext::Symbol(context) => symbol_context.push(context),
-            AssistantContext::FetchedUrl(context) => fetch_context.push(context),
-            AssistantContext::Thread(context) => thread_context.push(context),
-        }
-    }
-
-    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() {
-        result.push_str("<files>\n");
-        for context in file_context {
-            result.push_str(&context.context_buffer.text);
-        }
-        result.push_str("</files>\n");
-    }
-
-    if !directory_context.is_empty() {
-        result.push_str("<directories>\n");
-        for context in directory_context {
-            for context_buffer in &context.context_buffers {
-                result.push_str(&context_buffer.text);
-            }
-        }
-        result.push_str("</directories>\n");
-    }
-
-    if !symbol_context.is_empty() {
-        result.push_str("<symbols>\n");
-        for context in symbol_context {
-            result.push_str(&context.context_symbol.text);
-            result.push('\n');
-        }
-        result.push_str("</symbols>\n");
-    }
-
-    if !fetch_context.is_empty() {
-        result.push_str("<fetched_urls>\n");
-        for context in &fetch_context {
-            result.push_str(&context.url);
-            result.push('\n');
-            result.push_str(&context.text);
-            result.push('\n');
-        }
-        result.push_str("</fetched_urls>\n");
-    }
-
-    if !thread_context.is_empty() {
-        result.push_str("<conversation_threads>\n");
-        for context in &thread_context {
-            result.push_str(&context.summary(cx));
-            result.push('\n');
-            result.push_str(&context.text);
-            result.push('\n');
-        }
-        result.push_str("</conversation_threads>\n");
-    }
-
-    result.push_str("</context>\n");
-    Some(result)
-}
-
-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/symbol_context_picker.rs

@@ -1,438 +0,0 @@
-use std::cmp::Reverse;
-use std::sync::Arc;
-use std::sync::atomic::AtomicBool;
-
-use anyhow::{Context as _, Result};
-use fuzzy::{StringMatch, StringMatchCandidate};
-use gpui::{
-    App, AppContext, DismissEvent, Entity, FocusHandle, Focusable, Stateful, Task, WeakEntity,
-};
-use ordered_float::OrderedFloat;
-use picker::{Picker, PickerDelegate};
-use project::{DocumentSymbol, Symbol};
-use text::OffsetRangeExt;
-use ui::{ListItem, prelude::*};
-use util::ResultExt as _;
-use workspace::Workspace;
-
-use crate::context_picker::{ConfirmBehavior, ContextPicker};
-use crate::context_store::ContextStore;
-
-pub struct SymbolContextPicker {
-    picker: Entity<Picker<SymbolContextPickerDelegate>>,
-}
-
-impl SymbolContextPicker {
-    pub fn new(
-        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 picker = cx.new(|cx| Picker::uniform_list(delegate, window, cx));
-
-        Self { picker }
-    }
-}
-
-impl Focusable for SymbolContextPicker {
-    fn focus_handle(&self, cx: &App) -> FocusHandle {
-        self.picker.focus_handle(cx)
-    }
-}
-
-impl Render for SymbolContextPicker {
-    fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
-        self.picker.clone()
-    }
-}
-
-pub struct SymbolContextPickerDelegate {
-    context_picker: WeakEntity<ContextPicker>,
-    workspace: WeakEntity<Workspace>,
-    context_store: WeakEntity<ContextStore>,
-    confirm_behavior: ConfirmBehavior,
-    matches: Vec<SymbolEntry>,
-    selected_index: usize,
-}
-
-impl SymbolContextPickerDelegate {
-    pub fn new(
-        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,
-        }
-    }
-}
-
-impl PickerDelegate for SymbolContextPickerDelegate {
-    type ListItem = ListItem;
-
-    fn match_count(&self) -> usize {
-        self.matches.len()
-    }
-
-    fn selected_index(&self) -> usize {
-        self.selected_index
-    }
-
-    fn set_selected_index(
-        &mut self,
-        ix: usize,
-        _window: &mut Window,
-        _cx: &mut Context<Picker<Self>>,
-    ) {
-        self.selected_index = ix;
-    }
-
-    fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> Arc<str> {
-        "Search symbols…".into()
-    }
-
-    fn update_matches(
-        &mut self,
-        query: String,
-        window: &mut Window,
-        cx: &mut Context<Picker<Self>>,
-    ) -> Task<()> {
-        let Some(workspace) = self.workspace.upgrade() else {
-            return Task::ready(());
-        };
-
-        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 symbol_entries = context_store
-                .read_with(cx, |context_store, cx| {
-                    compute_symbol_entries(symbols, context_store, cx)
-                })
-                .log_err()
-                .unwrap_or_default();
-
-            this.update(cx, |this, _cx| {
-                this.delegate.matches = symbol_entries;
-            })
-            .log_err();
-        })
-    }
-
-    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;
-        };
-        let Some(workspace) = self.workspace.upgrade() else {
-            return;
-        };
-
-        let confirm_behavior = self.confirm_behavior;
-        let add_symbol_task = add_symbol(
-            mat.symbol.clone(),
-            true,
-            workspace,
-            self.context_store.clone(),
-            cx,
-        );
-
-        let selected_index = self.selected_index;
-        cx.spawn_in(window, async move |this, cx| {
-            let included = add_symbol_task.await?;
-            this.update_in(cx, |this, window, cx| {
-                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);
-    }
-
-    fn dismissed(&mut self, _: &mut Window, cx: &mut Context<Picker<Self>>) {
-        self.context_picker
-            .update(cx, |_, cx| {
-                cx.emit(DismissEvent);
-            })
-            .ok();
-    }
-
-    fn render_match(
-        &self,
-        ix: usize,
-        selected: bool,
-        _window: &mut Window,
-        _: &mut Context<Picker<Self>>,
-    ) -> Option<Self::ListItem> {
-        let mat = &self.matches[ix];
-
-        Some(ListItem::new(ix).inset(true).toggle_state(selected).child(
-            render_symbol_context_entry(
-                ElementId::NamedInteger("symbol-ctx-picker".into(), ix),
-                mat,
-            ),
-        ))
-    }
-}
-
-pub(crate) struct SymbolEntry {
-    pub symbol: Symbol,
-    pub is_included: bool,
-}
-
-pub(crate) fn add_symbol(
-    symbol: Symbol,
-    remove_if_exists: bool,
-    workspace: Entity<Workspace>,
-    context_store: WeakEntity<ContextStore>,
-    cx: &mut App,
-) -> Task<Result<bool>> {
-    let project = workspace.read(cx).project().clone();
-    let open_buffer_task = project.update(cx, |project, cx| {
-        project.open_buffer(symbol.path.clone(), cx)
-    });
-    cx.spawn(async move |cx| {
-        let buffer = open_buffer_task.await?;
-        let document_symbols = project
-            .update(cx, |project, cx| project.document_symbols(&buffer, cx))?
-            .await?;
-
-        // Try to find a matching document symbol. Document symbols include
-        // not only the symbol itself (e.g. function name), but they also
-        // include the context that they contain (e.g. function body).
-        let (name, range, enclosing_range) = if let Some(DocumentSymbol {
-            name,
-            range,
-            selection_range,
-            ..
-        }) =
-            find_matching_symbol(&symbol, document_symbols.as_slice())
-        {
-            (name, selection_range, range)
-        } else {
-            // If we do not find a matching document symbol, fall back to
-            // just the symbol itself
-            (symbol.name, symbol.range.clone(), symbol.range)
-        };
-
-        let (range, enclosing_range) = buffer.read_with(cx, |buffer, _| {
-            (
-                buffer.anchor_after(range.start)..buffer.anchor_before(range.end),
-                buffer.anchor_after(enclosing_range.start)
-                    ..buffer.anchor_before(enclosing_range.end),
-            )
-        })?;
-
-        context_store
-            .update(cx, move |context_store, cx| {
-                context_store.add_symbol(
-                    buffer,
-                    name.into(),
-                    range,
-                    enclosing_range,
-                    remove_if_exists,
-                    cx,
-                )
-            })?
-            .await
-    })
-}
-
-fn find_matching_symbol(symbol: &Symbol, candidates: &[DocumentSymbol]) -> Option<DocumentSymbol> {
-    let mut candidates = candidates.iter();
-    let mut candidate = candidates.next()?;
-
-    loop {
-        if candidate.range.start > symbol.range.end {
-            return None;
-        }
-        if candidate.range.end < symbol.range.start {
-            candidate = candidates.next()?;
-            continue;
-        }
-        if candidate.selection_range == symbol.range {
-            return Some(candidate.clone());
-        }
-        if candidate.range.start <= symbol.range.start && symbol.range.end <= candidate.range.end {
-            candidates = candidate.children.iter();
-            candidate = candidates.next()?;
-            continue;
-        }
-        return None;
-    }
-}
-
-pub(crate) fn search_symbols(
-    query: String,
-    cancellation_flag: Arc<AtomicBool>,
-    workspace: &Entity<Workspace>,
-    cx: &mut App,
-) -> Task<Result<Vec<(StringMatch, Symbol)>>> {
-    let symbols_task = workspace.update(cx, |workspace, cx| {
-        workspace
-            .project()
-            .update(cx, |project, cx| project.symbols(&query, cx))
-    });
-    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)
-                    })
-            })?;
-
-        const MAX_MATCHES: usize = 100;
-        let mut visible_matches = cx.background_executor().block(fuzzy::match_strings(
-            &visible_match_candidates,
-            &query,
-            false,
-            MAX_MATCHES,
-            &cancellation_flag,
-            cx.background_executor().clone(),
-        ));
-        let mut external_matches = cx.background_executor().block(fuzzy::match_strings(
-            &external_match_candidates,
-            &query,
-            false,
-            MAX_MATCHES - visible_matches.len().min(MAX_MATCHES),
-            &cancellation_flag,
-            cx.background_executor().clone(),
-        ));
-        let sort_key_for_match = |mat: &StringMatch| {
-            let symbol = &symbols[mat.candidate_id];
-            (Reverse(OrderedFloat(mat.score)), symbol.label.filter_text())
-        };
-
-        visible_matches.sort_unstable_by_key(sort_key_for_match);
-        external_matches.sort_unstable_by_key(sort_key_for_match);
-        let mut matches = visible_matches;
-        matches.append(&mut external_matches);
-
-        Ok(matches
-            .into_iter()
-            .map(|mut mat| {
-                let symbol = symbols[mat.candidate_id].clone();
-                let filter_start = symbol.label.filter_range.start;
-                for position in &mut mat.positions {
-                    *position += filter_start;
-                }
-                (mat, symbol)
-            })
-            .collect())
-    })
-}
-
-fn compute_symbol_entries(
-    symbols: Vec<(StringMatch, Symbol)>,
-    context_store: &ContextStore,
-    cx: &App,
-) -> Vec<SymbolEntry> {
-    let mut symbol_entries = Vec::with_capacity(symbols.len());
-    for (_, 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;
-            for included_symbol_id in symbols_for_path {
-                if included_symbol_id.name.as_ref() == symbol.name.as_str() {
-                    if let Some(buffer) = context_store.buffer_for_symbol(included_symbol_id) {
-                        let snapshot = buffer.read(cx).snapshot();
-                        let included_symbol_range =
-                            included_symbol_id.range.to_point_utf16(&snapshot);
-
-                        if included_symbol_range.start == symbol.range.start.0
-                            && included_symbol_range.end == symbol.range.end.0
-                        {
-                            is_included = true;
-                            break;
-                        }
-                    }
-                }
-            }
-            is_included
-        } else {
-            false
-        };
-
-        symbol_entries.push(SymbolEntry {
-            symbol,
-            is_included,
-        })
-    }
-    symbol_entries
-}
-
-pub fn render_symbol_context_entry(id: ElementId, entry: &SymbolEntry) -> Stateful<Div> {
-    let path = entry
-        .symbol
-        .path
-        .path
-        .file_name()
-        .map(|s| s.to_string_lossy())
-        .unwrap_or_default();
-    let symbol_location = format!("{} L{}", path, entry.symbol.range.start.0.row + 1);
-
-    h_flex()
-        .id(id)
-        .gap_1p5()
-        .w_full()
-        .child(
-            Icon::new(IconName::Code)
-                .size(IconSize::Small)
-                .color(Color::Muted),
-        )
-        .child(
-            h_flex()
-                .gap_1()
-                .child(Label::new(&entry.symbol.name))
-                .child(
-                    Label::new(symbol_location)
-                        .size(LabelSize::Small)
-                        .color(Color::Muted),
-                ),
-        )
-        .when(entry.is_included, |el| {
-            el.child(
-                h_flex()
-                    .w_full()
-                    .justify_end()
-                    .gap_0p5()
-                    .child(
-                        Icon::new(IconName::Check)
-                            .size(IconSize::Small)
-                            .color(Color::Success),
-                    )
-                    .child(Label::new("Added").size(LabelSize::Small)),
-            )
-        })
-}

crates/agent/src/message_editor.rs

@@ -1,874 +0,0 @@
-use std::sync::Arc;
-
-use crate::assistant_model_selector::ModelType;
-use collections::HashSet;
-use editor::actions::MoveUp;
-use editor::{ContextMenuOptions, ContextMenuPlacement, Editor, EditorElement, EditorStyle};
-use file_icons::FileIcons;
-use fs::Fs;
-use gpui::{
-    Animation, AnimationExt, App, DismissEvent, Entity, Focusable, Subscription, TextStyle,
-    WeakEntity, linear_color_stop, linear_gradient, point,
-};
-use language::Buffer;
-use language_model::{ConfiguredModel, LanguageModelRegistry};
-use language_model_selector::ToggleModelSelector;
-use multi_buffer;
-use project::Project;
-use settings::Settings;
-use std::time::Duration;
-use theme::ThemeSettings;
-use ui::{
-    ButtonLike, Disclosure, KeyBinding, PlatformStyle, PopoverMenu, PopoverMenuHandle, Tooltip,
-    prelude::*,
-};
-use util::ResultExt as _;
-use vim_mode_setting::VimModeSetting;
-use workspace::Workspace;
-
-use crate::assistant_model_selector::AssistantModelSelector;
-use crate::context_picker::{ConfirmBehavior, ContextPicker, ContextPickerCompletionProvider};
-use crate::context_store::{ContextStore, refresh_context_store_text};
-use crate::context_strip::{ContextStrip, ContextStripEvent, SuggestContextKind};
-use crate::profile_selector::ProfileSelector;
-use crate::thread::{RequestKind, Thread, TokenUsageRatio};
-use crate::thread_store::ThreadStore;
-use crate::{
-    AgentDiff, Chat, ChatMode, NewThread, OpenAgentDiff, RemoveAllContext, ThreadEvent,
-    ToggleContextPicker, ToggleProfileSelector,
-};
-
-pub struct MessageEditor {
-    thread: Entity<Thread>,
-    editor: Entity<Editor>,
-    #[allow(dead_code)]
-    workspace: WeakEntity<Workspace>,
-    project: Entity<Project>,
-    context_store: Entity<ContextStore>,
-    context_strip: Entity<ContextStrip>,
-    context_picker_menu_handle: PopoverMenuHandle<ContextPicker>,
-    inline_context_picker: Entity<ContextPicker>,
-    inline_context_picker_menu_handle: PopoverMenuHandle<ContextPicker>,
-    model_selector: Entity<AssistantModelSelector>,
-    profile_selector: Entity<ProfileSelector>,
-    edits_expanded: bool,
-    waiting_for_summaries_to_send: bool,
-    _subscriptions: Vec<Subscription>,
-}
-
-impl MessageEditor {
-    pub fn new(
-        fs: Arc<dyn Fs>,
-        workspace: WeakEntity<Workspace>,
-        context_store: Entity<ContextStore>,
-        thread_store: WeakEntity<ThreadStore>,
-        thread: Entity<Thread>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Self {
-        let context_picker_menu_handle = PopoverMenuHandle::default();
-        let inline_context_picker_menu_handle = PopoverMenuHandle::default();
-        let model_selector_menu_handle = PopoverMenuHandle::default();
-
-        let editor = cx.new(|cx| {
-            let mut editor = Editor::auto_height(10, window, cx);
-            editor.set_placeholder_text("Ask anything, @ to mention, ↑ to select", cx);
-            editor.set_show_indent_guides(false, cx);
-            editor.set_context_menu_options(ContextMenuOptions {
-                min_entries_visible: 12,
-                max_entries_visible: 12,
-                placement: Some(ContextMenuPlacement::Above),
-            });
-
-            editor
-        });
-
-        let editor_entity = editor.downgrade();
-        editor.update(cx, |editor, _| {
-            editor.set_completion_provider(Some(Box::new(ContextPickerCompletionProvider::new(
-                workspace.clone(),
-                context_store.downgrade(),
-                Some(thread_store.clone()),
-                editor_entity,
-            ))));
-        });
-
-        let inline_context_picker = cx.new(|cx| {
-            ContextPicker::new(
-                workspace.clone(),
-                Some(thread_store.clone()),
-                context_store.downgrade(),
-                ConfirmBehavior::Close,
-                window,
-                cx,
-            )
-        });
-
-        let context_strip = cx.new(|cx| {
-            ContextStrip::new(
-                context_store.clone(),
-                workspace.clone(),
-                Some(thread_store.clone()),
-                context_picker_menu_handle.clone(),
-                SuggestContextKind::File,
-                window,
-                cx,
-            )
-        });
-
-        let subscriptions = vec![
-            cx.subscribe_in(
-                &inline_context_picker,
-                window,
-                Self::handle_inline_context_picker_event,
-            ),
-            cx.subscribe_in(&context_strip, window, Self::handle_context_strip_event),
-        ];
-
-        Self {
-            editor: editor.clone(),
-            project: thread.read(cx).project().clone(),
-            thread,
-            workspace,
-            context_store,
-            context_strip,
-            context_picker_menu_handle,
-            inline_context_picker,
-            inline_context_picker_menu_handle,
-            model_selector: cx.new(|cx| {
-                AssistantModelSelector::new(
-                    fs.clone(),
-                    model_selector_menu_handle,
-                    editor.focus_handle(cx),
-                    ModelType::Default,
-                    window,
-                    cx,
-                )
-            }),
-            edits_expanded: false,
-            waiting_for_summaries_to_send: false,
-            profile_selector: cx
-                .new(|cx| ProfileSelector::new(fs, thread_store, editor.focus_handle(cx), cx)),
-            _subscriptions: subscriptions,
-        }
-    }
-
-    fn toggle_chat_mode(&mut self, _: &ChatMode, _window: &mut Window, cx: &mut Context<Self>) {
-        cx.notify();
-    }
-
-    fn toggle_context_picker(
-        &mut self,
-        _: &ToggleContextPicker,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        self.context_picker_menu_handle.toggle(window, cx);
-    }
-    pub fn remove_all_context(
-        &mut self,
-        _: &RemoveAllContext,
-        _window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        self.context_store.update(cx, |store, _cx| store.clear());
-        cx.notify();
-    }
-
-    fn chat(&mut self, _: &Chat, window: &mut Window, cx: &mut Context<Self>) {
-        if self.is_editor_empty(cx) {
-            return;
-        }
-
-        if self.thread.read(cx).is_generating() {
-            return;
-        }
-
-        self.send_to_model(RequestKind::Chat, window, cx);
-    }
-
-    fn is_editor_empty(&self, cx: &App) -> bool {
-        self.editor.read(cx).text(cx).is_empty()
-    }
-
-    fn is_model_selected(&self, cx: &App) -> bool {
-        LanguageModelRegistry::read_global(cx)
-            .default_model()
-            .is_some()
-    }
-
-    fn send_to_model(
-        &mut self,
-        request_kind: RequestKind,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        let model_registry = LanguageModelRegistry::read_global(cx);
-        let Some(ConfiguredModel { model, provider }) = model_registry.default_model() else {
-            return;
-        };
-
-        if provider.must_accept_terms(cx) {
-            cx.notify();
-            return;
-        }
-
-        let user_message = self.editor.update(cx, |editor, cx| {
-            let text = editor.text(cx);
-            editor.clear(window, cx);
-            text
-        });
-
-        let refresh_task =
-            refresh_context_store_text(self.context_store.clone(), &HashSet::default(), cx);
-
-        let system_prompt_context_task = self.thread.read(cx).load_system_prompt_context(cx);
-
-        let thread = self.thread.clone();
-        let context_store = self.context_store.clone();
-        let checkpoint = self.project.read(cx).git_store().read(cx).checkpoint(cx);
-
-        cx.spawn(async move |this, cx| {
-            let checkpoint = checkpoint.await.ok();
-            refresh_task.await;
-            let (system_prompt_context, load_error) = system_prompt_context_task.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
-                .update(cx, |thread, cx| {
-                    let context = context_store.read(cx).context().clone();
-                    thread.insert_user_message(user_message, context, checkpoint, cx);
-                })
-                .ok();
-
-            if let Some(wait_for_summaries) = context_store
-                .update(cx, |context_store, cx| context_store.wait_for_summaries(cx))
-                .log_err()
-            {
-                this.update(cx, |this, cx| {
-                    this.waiting_for_summaries_to_send = true;
-                    cx.notify();
-                })
-                .ok();
-
-                wait_for_summaries.await;
-
-                this.update(cx, |this, cx| {
-                    this.waiting_for_summaries_to_send = false;
-                    cx.notify();
-                })
-                .ok();
-            }
-
-            // Send to model after summaries are done
-            thread
-                .update(cx, |thread, cx| {
-                    thread.send_to_model(model, request_kind, cx);
-                })
-                .ok();
-        })
-        .detach();
-    }
-
-    fn handle_inline_context_picker_event(
-        &mut self,
-        _inline_context_picker: &Entity<ContextPicker>,
-        _event: &DismissEvent,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        let editor_focus_handle = self.editor.focus_handle(cx);
-        window.focus(&editor_focus_handle);
-    }
-
-    fn handle_context_strip_event(
-        &mut self,
-        _context_strip: &Entity<ContextStrip>,
-        event: &ContextStripEvent,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        match event {
-            ContextStripEvent::PickerDismissed
-            | ContextStripEvent::BlurredEmpty
-            | ContextStripEvent::BlurredDown => {
-                let editor_focus_handle = self.editor.focus_handle(cx);
-                window.focus(&editor_focus_handle);
-            }
-            ContextStripEvent::BlurredUp => {}
-        }
-    }
-
-    fn move_up(&mut self, _: &MoveUp, window: &mut Window, cx: &mut Context<Self>) {
-        if self.context_picker_menu_handle.is_deployed()
-            || self.inline_context_picker_menu_handle.is_deployed()
-        {
-            cx.propagate();
-        } else {
-            self.context_strip.focus_handle(cx).focus(window);
-        }
-    }
-
-    fn handle_review_click(&self, window: &mut Window, cx: &mut Context<Self>) {
-        AgentDiff::deploy(self.thread.clone(), self.workspace.clone(), window, cx).log_err();
-    }
-
-    fn handle_file_click(
-        &self,
-        buffer: Entity<Buffer>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        if let Ok(diff) = AgentDiff::deploy(self.thread.clone(), self.workspace.clone(), window, cx)
-        {
-            let path_key = multi_buffer::PathKey::for_buffer(&buffer, cx);
-            diff.update(cx, |diff, cx| diff.move_to_path(path_key, window, cx));
-        }
-    }
-}
-
-impl Focusable for MessageEditor {
-    fn focus_handle(&self, cx: &App) -> gpui::FocusHandle {
-        self.editor.focus_handle(cx)
-    }
-}
-
-impl Render for MessageEditor {
-    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let font_size = TextSize::Default.rems(cx);
-        let line_height = font_size.to_pixels(window.rem_size()) * 1.5;
-
-        let focus_handle = self.editor.focus_handle(cx);
-        let inline_context_picker = self.inline_context_picker.clone();
-
-        let thread = self.thread.read(cx);
-        let is_generating = thread.is_generating();
-        let total_token_usage = thread.total_token_usage(cx);
-        let is_model_selected = self.is_model_selected(cx);
-        let is_editor_empty = self.is_editor_empty(cx);
-        let needs_confirmation =
-            thread.has_pending_tool_uses() && thread.tools_needing_confirmation().next().is_some();
-
-        let submit_label_color = if is_editor_empty {
-            Color::Muted
-        } else {
-            Color::Default
-        };
-
-        let vim_mode_enabled = VimModeSetting::get_global(cx).0;
-        let platform = PlatformStyle::platform();
-        let linux = platform == PlatformStyle::Linux;
-        let windows = platform == PlatformStyle::Windows;
-        let button_width = if linux || windows || vim_mode_enabled {
-            px(82.)
-        } else {
-            px(64.)
-        };
-
-        let action_log = self.thread.read(cx).action_log();
-        let changed_buffers = action_log.read(cx).changed_buffers(cx);
-        let changed_buffers_count = changed_buffers.len();
-
-        let editor_bg_color = cx.theme().colors().editor_background;
-        let border_color = cx.theme().colors().border;
-        let active_color = cx.theme().colors().element_selected;
-        let bg_edit_files_disclosure = editor_bg_color.blend(active_color.opacity(0.3));
-
-        v_flex()
-            .size_full()
-            .when(self.waiting_for_summaries_to_send, |parent| {
-                parent.child(
-                    h_flex().py_3().w_full().justify_center().child(
-                        h_flex()
-                            .flex_none()
-                            .px_2()
-                            .py_2()
-                            .bg(editor_bg_color)
-                            .border_1()
-                            .border_color(cx.theme().colors().border_variant)
-                            .rounded_lg()
-                            .shadow_md()
-                            .gap_1()
-                            .child(
-                                Icon::new(IconName::ArrowCircle)
-                                    .size(IconSize::XSmall)
-                                    .color(Color::Muted)
-                                    .with_animation(
-                                        "arrow-circle",
-                                        Animation::new(Duration::from_secs(2)).repeat(),
-                                        |icon, delta| {
-                                            icon.transform(gpui::Transformation::rotate(
-                                                gpui::percentage(delta),
-                                            ))
-                                        },
-                                    ),
-                            )
-                            .child(
-                                Label::new("Summarizing context…")
-                                    .size(LabelSize::XSmall)
-                                    .color(Color::Muted),
-                            ),
-                    ),
-                )
-            })
-            .when(is_generating, |parent| {
-                let focus_handle = self.editor.focus_handle(cx).clone();
-                parent.child(
-                    h_flex().py_3().w_full().justify_center().child(
-                        h_flex()
-                            .flex_none()
-                            .pl_2()
-                            .pr_1()
-                            .py_1()
-                            .bg(editor_bg_color)
-                            .border_1()
-                            .border_color(cx.theme().colors().border_variant)
-                            .rounded_lg()
-                            .shadow_md()
-                            .gap_1()
-                            .child(
-                                Icon::new(IconName::ArrowCircle)
-                                    .size(IconSize::XSmall)
-                                    .color(Color::Muted)
-                                    .with_animation(
-                                        "arrow-circle",
-                                        Animation::new(Duration::from_secs(2)).repeat(),
-                                        |icon, delta| {
-                                            icon.transform(gpui::Transformation::rotate(
-                                                gpui::percentage(delta),
-                                            ))
-                                        },
-                                    ),
-                            )
-                            .child({
-
-
-                                Label::new(if needs_confirmation {
-                                    "Waiting for confirmation…"
-                                } else {
-                                    "Generating…"
-                                })
-                                .size(LabelSize::XSmall)
-                                .color(Color::Muted)
-                            })
-                            .child(ui::Divider::vertical())
-                            .child(
-                                Button::new("cancel-generation", "Cancel")
-                                    .label_size(LabelSize::XSmall)
-                                    .key_binding(
-                                        KeyBinding::for_action_in(
-                                            &editor::actions::Cancel,
-                                            &focus_handle,
-                                            window,
-                                            cx,
-                                        )
-                                        .map(|kb| kb.size(rems_from_px(10.))),
-                                    )
-                                    .on_click(move |_event, window, cx| {
-                                        focus_handle.dispatch_action(
-                                            &editor::actions::Cancel,
-                                            window,
-                                            cx,
-                                        );
-                                    }),
-                            ),
-                    ),
-                )
-            })
-            .when(changed_buffers_count > 0, |parent| {
-                parent.child(
-                    v_flex()
-                        .mx_2()
-                        .bg(bg_edit_files_disclosure)
-                        .border_1()
-                        .border_b_0()
-                        .border_color(border_color)
-                        .rounded_t_md()
-                        .shadow(smallvec::smallvec![gpui::BoxShadow {
-                            color: gpui::black().opacity(0.15),
-                            offset: point(px(1.), px(-1.)),
-                            blur_radius: px(3.),
-                            spread_radius: px(0.),
-                        }])
-                        .child(
-                            h_flex()
-                                .id("edits-container")
-                                .p_1p5()
-                                .justify_between()
-                                .when(self.edits_expanded, |this| {
-                                    this.border_b_1().border_color(border_color)
-                                })
-                                .cursor_pointer()
-                                .on_click(cx.listener(|this, _, window, cx| {
-                                    this.handle_review_click(window, cx)
-                                }))
-                                .child(
-                                    h_flex()
-                                        .gap_1()
-                                        .child(
-                                            Disclosure::new(
-                                                "edits-disclosure",
-                                                self.edits_expanded,
-                                            )
-                                            .on_click(
-                                                cx.listener(|this, _ev, _window, cx| {
-                                                    this.edits_expanded = !this.edits_expanded;
-                                                    cx.notify();
-                                                }),
-                                            ),
-                                        )
-                                        .child(
-                                            Label::new("Edits")
-                                                .size(LabelSize::Small)
-                                                .color(Color::Muted),
-                                        )
-                                        .child(
-                                            Label::new("•")
-                                                .size(LabelSize::XSmall)
-                                                .color(Color::Muted),
-                                        )
-                                        .child(
-                                            Label::new(format!(
-                                                "{} {}",
-                                                changed_buffers_count,
-                                                if changed_buffers_count == 1 {
-                                                    "file"
-                                                } else {
-                                                    "files"
-                                                }
-                                            ))
-                                            .size(LabelSize::Small)
-                                            .color(Color::Muted),
-                                        ),
-                                )
-                                .child(
-                                    Button::new("review", "Review Changes")
-                                        .label_size(LabelSize::Small)
-                                        .key_binding(
-                                            KeyBinding::for_action_in(
-                                                &OpenAgentDiff,
-                                                &focus_handle,
-                                                window,
-                                                cx,
-                                            )
-                                            .map(|kb| kb.size(rems_from_px(12.))),
-                                        )
-                                        .on_click(cx.listener(|this, _, window, cx| {
-                                            this.handle_review_click(window, cx)
-                                        })),
-                                ),
-                        )
-                        .when(self.edits_expanded, |parent| {
-                            parent.child(
-                                v_flex().bg(cx.theme().colors().editor_background).children(
-                                    changed_buffers.into_iter().enumerate().flat_map(
-                                        |(index, (buffer, _diff))| {
-                                            let file = buffer.read(cx).file()?;
-                                            let path = file.path();
-
-                                            let parent_label = path.parent().and_then(|parent| {
-                                                let parent_str = parent.to_string_lossy();
-
-                                                if parent_str.is_empty() {
-                                                    None
-                                                } else {
-                                                    Some(
-                                                        Label::new(format!(
-                                                            "{}{}",
-                                                            parent_str,
-                                                            std::path::MAIN_SEPARATOR_STR
-                                                        ))
-                                                        .color(Color::Muted)
-                                                        .size(LabelSize::XSmall)
-                                                        .buffer_font(cx),
-                                                    )
-                                                }
-                                            });
-
-                                            let name_label = path.file_name().map(|name| {
-                                                Label::new(name.to_string_lossy().to_string())
-                                                    .size(LabelSize::XSmall)
-                                                    .buffer_font(cx)
-                                            });
-
-                                            let file_icon = FileIcons::get_icon(&path, cx)
-                                                .map(Icon::from_path)
-                                                .map(|icon| {
-                                                    icon.color(Color::Muted).size(IconSize::Small)
-                                                })
-                                                .unwrap_or_else(|| {
-                                                    Icon::new(IconName::File)
-                                                        .color(Color::Muted)
-                                                        .size(IconSize::Small)
-                                                });
-
-                                            let element = div()
-                                                .relative()
-                                                .py_1()
-                                                .px_2()
-                                                .when(index + 1 < changed_buffers_count, |parent| {
-                                                    parent.border_color(border_color).border_b_1()
-                                                })
-                                                .child(
-                                                    h_flex()
-                                                        .gap_2()
-                                                        .justify_between()
-                                                        .child(
-                                                            h_flex()
-                                                                .id(("file-container", index))
-                                                                .pr_8()
-                                                                .gap_1p5()
-                                                                .max_w_full()
-                                                                .overflow_x_scroll()
-                                                                .cursor_pointer()
-                                                                .on_click({
-                                                                    let buffer = buffer.clone();
-                                                                    cx.listener(move |this, _, window, cx| {
-                                                                        this.handle_file_click(buffer.clone(), window, cx);
-                                                                    })
-                                                                })
-                                                                .tooltip(
-                                                                    Tooltip::text(format!("Review {}", path.display()))
-                                                                )
-                                                                .child(file_icon)
-                                                                .child(
-                                                                    h_flex()
-                                                                        .children(parent_label)
-                                                                        .children(name_label),
-                                                                ) // TODO: show lines changed
-                                                                .child(
-                                                                    Label::new("+")
-                                                                        .color(Color::Created),
-                                                                )
-                                                                .child(
-                                                                    Label::new("-")
-                                                                        .color(Color::Deleted),
-                                                                ),
-                                                        )
-                                                        .child(
-                                                            div()
-                                                                .h_full()
-                                                                .absolute()
-                                                                .w_8()
-                                                                .bottom_0()
-                                                                .right_0()
-                                                                .bg(linear_gradient(
-                                                                    90.,
-                                                                    linear_color_stop(
-                                                                        editor_bg_color,
-                                                                        1.,
-                                                                    ),
-                                                                    linear_color_stop(
-                                                                        editor_bg_color
-                                                                            .opacity(0.2),
-                                                                        0.,
-                                                                    ),
-                                                                )),
-                                                        ),
-                                                );
-
-                                            Some(element)
-                                        },
-                                    ),
-                                ),
-                            )
-                        }),
-                )
-            })
-            .child(
-                v_flex()
-                    .key_context("MessageEditor")
-                    .on_action(cx.listener(Self::chat))
-                    .on_action(cx.listener(|this, _: &ToggleProfileSelector, window, cx| {
-                        this.profile_selector
-                            .read(cx)
-                            .menu_handle()
-                            .toggle(window, cx);
-                    }))
-                    .on_action(cx.listener(|this, _: &ToggleModelSelector, window, cx| {
-                        this.model_selector
-                            .update(cx, |model_selector, cx| model_selector.toggle(window, cx));
-                    }))
-                    .on_action(cx.listener(Self::toggle_context_picker))
-                    .on_action(cx.listener(Self::remove_all_context))
-                    .on_action(cx.listener(Self::move_up))
-                    .on_action(cx.listener(Self::toggle_chat_mode))
-                    .gap_2()
-                    .p_2()
-                    .bg(editor_bg_color)
-                    .border_t_1()
-                    .border_color(cx.theme().colors().border)
-                    .child(h_flex().justify_between().child(self.context_strip.clone()))
-                    .child(
-                        v_flex()
-                            .gap_5()
-                            .child({
-                                    let settings = ThemeSettings::get_global(cx);
-                                    let text_style = TextStyle {
-                                        color: cx.theme().colors().text,
-                                        font_family: settings.ui_font.family.clone(),
-                                        font_fallbacks: settings.ui_font.fallbacks.clone(),
-                                        font_features: settings.ui_font.features.clone(),
-                                        font_size: font_size.into(),
-                                        font_weight: settings.ui_font.weight,
-                                        line_height: line_height.into(),
-                                        ..Default::default()
-                                    };
-
-                                    EditorElement::new(
-                                        &self.editor,
-                                        EditorStyle {
-                                            background: editor_bg_color,
-                                            local_player: cx.theme().players().local(),
-                                            text: text_style,
-                                            syntax: cx.theme().syntax().clone(),
-                                            ..Default::default()
-                                        },
-                                    ).into_any()
-
-                            })
-                            .child(
-                                PopoverMenu::new("inline-context-picker")
-                                    .menu(move |window, cx| {
-                                        inline_context_picker.update(cx, |this, cx| {
-                                            this.init(window, cx);
-                                        });
-
-                                        Some(inline_context_picker.clone())
-                                    })
-                                    .attach(gpui::Corner::TopLeft)
-                                    .anchor(gpui::Corner::BottomLeft)
-                                    .offset(gpui::Point {
-                                        x: px(0.0),
-                                        y: (-ThemeSettings::get_global(cx).ui_font_size(cx) * 2)
-                                            - px(4.0),
-                                    })
-                                    .with_handle(self.inline_context_picker_menu_handle.clone()),
-                            )
-                            .child(
-                                h_flex()
-                                    .justify_between()
-                                    .child(h_flex().gap_2().child(self.profile_selector.clone()))
-                                    .child(
-                                        h_flex().gap_1().child(self.model_selector.clone()).child(
-                                            ButtonLike::new("submit-message")
-                                                .width(button_width.into())
-                                                .style(ButtonStyle::Filled)
-                                                .disabled(
-                                                    is_editor_empty
-                                                        || !is_model_selected
-                                                        || is_generating
-                                                        || self.waiting_for_summaries_to_send
-                                                )
-                                                .child(
-                                                    h_flex()
-                                                        .w_full()
-                                                        .justify_between()
-                                                        .child(
-                                                            Label::new("Submit")
-                                                                .size(LabelSize::Small)
-                                                                .color(submit_label_color),
-                                                        )
-                                                        .children(
-                                                            KeyBinding::for_action_in(
-                                                                &Chat,
-                                                                &focus_handle,
-                                                                window,
-                                                                cx,
-                                                            )
-                                                            .map(|binding| {
-                                                                binding
-                                                                    .when(vim_mode_enabled, |kb| {
-                                                                        kb.size(rems_from_px(12.))
-                                                                    })
-                                                                    .into_any_element()
-                                                            }),
-                                                        ),
-                                                )
-                                                .on_click(move |_event, window, cx| {
-                                                    focus_handle.dispatch_action(&Chat, window, cx);
-                                                })
-                                                .when(is_editor_empty, |button| {
-                                                    button.tooltip(Tooltip::text(
-                                                        "Type a message to submit",
-                                                    ))
-                                                })
-                                                .when(is_generating, |button| {
-                                                    button.tooltip(Tooltip::text(
-                                                        "Cancel to submit a new message",
-                                                    ))
-                                                })
-                                                .when(!is_model_selected, |button| {
-                                                    button.tooltip(Tooltip::text(
-                                                        "Select a model to continue",
-                                                    ))
-                                                }),
-                                        ),
-                                    ),
-                            ),
-                    )
-            )
-            .when(total_token_usage.ratio != TokenUsageRatio::Normal, |parent| {
-                parent.child(
-                    h_flex()
-                        .p_2()
-                        .gap_2()
-                        .flex_wrap()
-                        .justify_between()
-                        .bg(cx.theme().status().warning_background.opacity(0.1))
-                        .border_t_1()
-                        .border_color(cx.theme().colors().border)
-                        .child(
-                            h_flex()
-                                .gap_2()
-                                .items_start()
-                                .child(
-                                    h_flex()
-                                        .h(line_height)
-                                        .justify_center()
-                                        .child(
-                                            Icon::new(IconName::Warning)
-                                                .color(Color::Warning)
-                                                .size(IconSize::XSmall),
-                                        ),
-                                )
-                                .child(
-                                    v_flex()
-                                        .mr_auto()
-                                        .child(Label::new("Thread reaching the token limit soon").size(LabelSize::Small))
-                                        .child(
-                                            Label::new(
-                                                "Start a new thread from a summary to continue the conversation.",
-                                            )
-                                            .size(LabelSize::Small)
-                                            .color(Color::Muted),
-                                        ),
-                                ),
-                        )
-                        .child(
-                            Button::new("new-thread", "Start New Thread")
-                                .on_click(cx.listener(|this, _, window, cx| {
-                                    let from_thread_id = Some(this.thread.read(cx).id().clone());
-
-                                    window.dispatch_action(Box::new(NewThread {
-                                        from_thread_id
-                                    }), cx);
-                                }))
-                                .icon(IconName::Plus)
-                                .icon_position(IconPosition::Start)
-                                .icon_size(IconSize::Small)
-                                .style(ButtonStyle::Tinted(ui::TintColor::Accent))
-                                .label_size(LabelSize::Small),
-                        ),
-                )
-            })
-    }
-}

crates/agent/src/profile_selector.rs

@@ -1,189 +0,0 @@
-use std::sync::Arc;
-
-use assistant_settings::{AgentProfile, AgentProfileId, AssistantSettings};
-use fs::Fs;
-use gpui::{Action, Entity, FocusHandle, Subscription, WeakEntity, prelude::*};
-use indexmap::IndexMap;
-use language_model::LanguageModelRegistry;
-use settings::{Settings as _, SettingsStore, update_settings_file};
-use ui::{
-    ButtonLike, ContextMenu, ContextMenuEntry, KeyBinding, PopoverMenu, PopoverMenuHandle, Tooltip,
-    prelude::*,
-};
-use util::ResultExt as _;
-
-use crate::{ManageProfiles, ThreadStore, ToggleProfileSelector};
-
-pub struct ProfileSelector {
-    profiles: IndexMap<AgentProfileId, AgentProfile>,
-    fs: Arc<dyn Fs>,
-    thread_store: WeakEntity<ThreadStore>,
-    focus_handle: FocusHandle,
-    menu_handle: PopoverMenuHandle<ContextMenu>,
-    _subscriptions: Vec<Subscription>,
-}
-
-impl ProfileSelector {
-    pub fn new(
-        fs: Arc<dyn Fs>,
-        thread_store: WeakEntity<ThreadStore>,
-        focus_handle: FocusHandle,
-        cx: &mut Context<Self>,
-    ) -> Self {
-        let settings_subscription = cx.observe_global::<SettingsStore>(move |this, cx| {
-            this.refresh_profiles(cx);
-        });
-
-        let mut this = Self {
-            profiles: IndexMap::default(),
-            fs,
-            thread_store,
-            focus_handle,
-            menu_handle: PopoverMenuHandle::default(),
-            _subscriptions: vec![settings_subscription],
-        };
-        this.refresh_profiles(cx);
-
-        this
-    }
-
-    pub fn menu_handle(&self) -> PopoverMenuHandle<ContextMenu> {
-        self.menu_handle.clone()
-    }
-
-    fn refresh_profiles(&mut self, cx: &mut Context<Self>) {
-        let settings = AssistantSettings::get_global(cx);
-
-        self.profiles = settings.profiles.clone();
-    }
-
-    fn build_context_menu(
-        &self,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Entity<ContextMenu> {
-        ContextMenu::build(window, cx, |mut menu, _window, cx| {
-            let settings = AssistantSettings::get_global(cx);
-            let icon_position = IconPosition::End;
-
-            menu = menu.header("Profiles");
-            for (profile_id, profile) in self.profiles.clone() {
-                menu = menu.toggleable_entry(
-                    profile.name.clone(),
-                    profile_id == settings.default_profile,
-                    icon_position,
-                    None,
-                    {
-                        let fs = self.fs.clone();
-                        let thread_store = self.thread_store.clone();
-                        move |_window, cx| {
-                            update_settings_file::<AssistantSettings>(fs.clone(), cx, {
-                                let profile_id = profile_id.clone();
-                                move |settings, _cx| {
-                                    settings.set_profile(profile_id.clone());
-                                }
-                            });
-
-                            thread_store
-                                .update(cx, |this, cx| {
-                                    this.load_profile_by_id(&profile_id, cx);
-                                })
-                                .log_err();
-                        }
-                    },
-                );
-            }
-
-            menu = menu.separator();
-            menu = menu.header("Customize Current Profile");
-            menu = menu.item(ContextMenuEntry::new("Tools…").handler({
-                let profile_id = settings.default_profile.clone();
-                move |window, cx| {
-                    window.dispatch_action(
-                        ManageProfiles::customize_tools(profile_id.clone()).boxed_clone(),
-                        cx,
-                    );
-                }
-            }));
-
-            menu = menu.separator();
-            menu = menu.item(ContextMenuEntry::new("Configure Profiles…").handler(
-                move |window, cx| {
-                    window.dispatch_action(ManageProfiles::default().boxed_clone(), cx);
-                },
-            ));
-
-            menu
-        })
-    }
-}
-
-impl Render for ProfileSelector {
-    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let settings = AssistantSettings::get_global(cx);
-        let profile_id = &settings.default_profile;
-        let profile = settings.profiles.get(profile_id);
-
-        let selected_profile = profile
-            .map(|profile| profile.name.clone())
-            .unwrap_or_else(|| "Unknown".into());
-
-        let model_registry = LanguageModelRegistry::read_global(cx);
-        let supports_tools = model_registry
-            .default_model()
-            .map_or(false, |default| default.model.supports_tools());
-
-        let icon = match profile_id.as_str() {
-            "write" => IconName::Pencil,
-            "ask" => IconName::MessageBubbles,
-            _ => IconName::UserRoundPen,
-        };
-
-        let this = cx.entity().clone();
-        let focus_handle = self.focus_handle.clone();
-        PopoverMenu::new("profile-selector")
-            .menu(move |window, cx| {
-                Some(this.update(cx, |this, cx| this.build_context_menu(window, cx)))
-            })
-            .trigger(if supports_tools {
-                ButtonLike::new("profile-selector-button").child(
-                    h_flex()
-                        .gap_1()
-                        .child(Icon::new(icon).size(IconSize::XSmall).color(Color::Muted))
-                        .child(
-                            Label::new(selected_profile)
-                                .size(LabelSize::Small)
-                                .color(Color::Muted),
-                        )
-                        .child(
-                            Icon::new(IconName::ChevronDown)
-                                .size(IconSize::XSmall)
-                                .color(Color::Muted),
-                        )
-                        .child(div().opacity(0.5).children({
-                            let focus_handle = focus_handle.clone();
-                            KeyBinding::for_action_in(
-                                &ToggleProfileSelector,
-                                &focus_handle,
-                                window,
-                                cx,
-                            )
-                            .map(|kb| kb.size(rems_from_px(10.)))
-                        })),
-                )
-            } else {
-                ButtonLike::new("tools-not-supported-button")
-                    .disabled(true)
-                    .child(
-                        h_flex().gap_1().child(
-                            Label::new("No Tools")
-                                .size(LabelSize::Small)
-                                .color(Color::Muted),
-                        ),
-                    )
-                    .tooltip(Tooltip::text("The current model does not support tools."))
-            })
-            .anchor(gpui::Corner::BottomLeft)
-            .with_handle(self.menu_handle.clone())
-    }
-}

crates/agent/src/ui.rs

@@ -1,5 +0,0 @@
-mod agent_notification;
-mod context_pill;
-
-pub use agent_notification::*;
-pub use context_pill::*;

crates/anthropic/Cargo.toml

@@ -26,4 +26,3 @@ 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::str::FromStr;
+use std::{pin::Pin, str::FromStr};
 
-use anyhow::{Context as _, Result, anyhow};
+use anyhow::{anyhow, Context as _, Result};
 use chrono::{DateTime, Utc};
-use futures::{AsyncBufReadExt, AsyncReadExt, StreamExt, io::BufReader, stream::BoxStream};
+use futures::{io::BufReader, stream::BoxStream, AsyncBufReadExt, AsyncReadExt, Stream, StreamExt};
 use http_client::http::{HeaderMap, HeaderValue};
 use http_client::{AsyncBody, HttpClient, Method, Request as HttpRequest};
 use serde::{Deserialize, Serialize};
@@ -220,23 +220,16 @@ impl Model {
             .map(|header| header.to_string())
             .collect::<Vec<_>>();
 
-        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(),
-                );
-            }
-            _ => {}
+        if let Self::Custom {
+            extra_beta_headers, ..
+        } = self
+        {
+            headers.extend(
+                extra_beta_headers
+                    .iter()
+                    .filter(|header| !header.trim().is_empty())
+                    .cloned(),
+            );
         }
 
         headers.join(",")
@@ -321,54 +314,38 @@ 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: Option<RateLimit>,
-    pub tokens: Option<RateLimit>,
-    pub input_tokens: Option<RateLimit>,
-    pub output_tokens: Option<RateLimit>,
+    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>,
 }
 
 impl RateLimitInfo {
-    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(),
-        }
+    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,
+        })
     }
 }
 
@@ -434,7 +411,7 @@ pub async fn stream_completion_with_rate_limit_info(
                 }
             })
             .boxed();
-        Ok((stream, Some(rate_limits)))
+        Ok((stream, rate_limits.log_err()))
     } else {
         let mut body = Vec::new();
         response
@@ -460,6 +437,50 @@ 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 {
@@ -564,13 +585,6 @@ pub enum Thinking {
     Enabled { budget_tokens: Option<u32> },
 }
 
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(untagged)]
-pub enum StringOrContents {
-    String(String),
-    Content(Vec<RequestContent>),
-}
-
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Request {
     pub model: String,
@@ -583,7 +597,7 @@ pub struct Request {
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub tool_choice: Option<ToolChoice>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub system: Option<StringOrContents>,
+    pub system: Option<String>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub metadata: Option<Metadata>,
     #[serde(default, skip_serializing_if = "Vec::is_empty")]

crates/askpass/Cargo.toml

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

crates/askpass/src/askpass.rs

@@ -5,9 +5,9 @@ use std::time::Duration;
 use anyhow::Context as _;
 use futures::channel::{mpsc, oneshot};
 #[cfg(unix)]
-use futures::{AsyncBufReadExt as _, io::BufReader};
+use futures::{io::BufReader, AsyncBufReadExt as _};
 #[cfg(unix)]
-use futures::{AsyncWriteExt as _, FutureExt as _, select_biased};
+use futures::{select_biased, AsyncWriteExt as _, FutureExt as _};
 use futures::{SinkExt, StreamExt};
 use gpui::{AsyncApp, BackgroundExecutor, Task};
 #[cfg(unix)]

crates/assets/Cargo.toml

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

crates/assets/src/assets.rs

@@ -57,11 +57,10 @@ impl Assets {
 
     pub fn load_test_fonts(&self, cx: &App) {
         cx.text_system()
-            .add_fonts(vec![
-                self.load("fonts/plex-mono/ZedPlexMono-Regular.ttf")
-                    .unwrap()
-                    .unwrap(),
-            ])
+            .add_fonts(vec![self
+                .load("fonts/plex-mono/ZedPlexMono-Regular.ttf")
+                .unwrap()
+                .unwrap()])
             .unwrap()
     }
 }

crates/assistant/Cargo.toml

@@ -48,6 +48,7 @@ lsp.workspace = true
 menu.workspace = true
 multi_buffer.workspace = true
 parking_lot.workspace = true
+paths.workspace = true
 project.workspace = true
 prompt_library.workspace = true
 prompt_store.workspace = true
@@ -55,6 +56,7 @@ proto.workspace = true
 rope.workspace = true
 schemars.workspace = true
 search.workspace = true
+semantic_index.workspace = true
 serde.workspace = true
 settings.workspace = true
 smol.workspace = true
@@ -69,7 +71,6 @@ 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

@@ -10,15 +10,17 @@ use std::sync::Arc;
 
 use assistant_settings::AssistantSettings;
 use assistant_slash_command::SlashCommandRegistry;
+use assistant_slash_commands::{ProjectSlashCommandFeatureFlag, SearchSlashCommandFeatureFlag};
 use client::Client;
 use command_palette_hooks::CommandPaletteFilter;
 use feature_flags::FeatureFlagAppExt;
 use fs::Fs;
-use gpui::{App, Global, ReadGlobal, UpdateGlobal, actions};
+use gpui::{actions, App, Global, UpdateGlobal};
 use language_model::{
     LanguageModelId, LanguageModelProviderId, LanguageModelRegistry, LanguageModelResponseMessage,
 };
 use prompt_store::PromptBuilder;
+use semantic_index::{CloudEmbeddingProvider, SemanticDb};
 use serde::Deserialize;
 use settings::{Settings, SettingsStore};
 
@@ -84,10 +86,6 @@ impl Assistant {
             filter.show_namespace(Self::NAMESPACE);
         });
     }
-
-    pub fn enabled(cx: &App) -> bool {
-        Self::global(cx).enabled
-    }
 }
 
 pub fn init(
@@ -100,6 +98,33 @@ pub fn init(
     AssistantSettings::register(cx);
     SlashCommandSettings::register(cx);
 
+    cx.spawn({
+        let client = client.clone();
+        async move |cx| {
+            let is_search_slash_command_enabled = cx
+                .update(|cx| cx.wait_for_flag::<SearchSlashCommandFeatureFlag>())?
+                .await;
+            let is_project_slash_command_enabled = cx
+                .update(|cx| cx.wait_for_flag::<ProjectSlashCommandFeatureFlag>())?
+                .await;
+
+            if !is_search_slash_command_enabled && !is_project_slash_command_enabled {
+                return Ok(());
+            }
+
+            let embedding_provider = CloudEmbeddingProvider::new(client.clone());
+            let semantic_index = SemanticDb::new(
+                paths::embeddings_dir().join("semantic-index-db.0.mdb"),
+                Arc::new(embedding_provider),
+                cx,
+            )
+            .await?;
+
+            cx.update(|cx| cx.set_global(semantic_index))
+        }
+    })
+    .detach();
+
     assistant_context_editor::init(client.clone(), cx);
     prompt_library::init(cx);
     init_language_model_settings(cx);
@@ -108,7 +133,7 @@ pub fn init(
     assistant_panel::init(cx);
     context_server::init(cx);
 
-    register_slash_commands(cx);
+    register_slash_commands(Some(prompt_builder.clone()), cx);
     inline_assistant::init(
         fs.clone(),
         prompt_builder.clone(),
@@ -161,38 +186,12 @@ 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());
-
-    // 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 editor_provider_name =
+        LanguageModelProviderId::from(settings.editor_model.provider.clone());
+    let editor_model_id = LanguageModelId::from(settings.editor_model.model.clone());
     let inline_alternatives = settings
         .inline_alternatives
         .iter()
@@ -203,34 +202,14 @@ fn update_active_language_model_from_settings(cx: &mut App) {
             )
         })
         .collect::<Vec<_>>();
-
     LanguageModelRegistry::global(cx).update(cx, |registry, 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_active_model(&active_model_provider_name, &active_model_id, cx);
+        registry.select_editor_model(&editor_provider_name, &editor_model_id, cx);
         registry.select_inline_alternative_models(inline_alternatives, cx);
     });
 }
 
-fn register_slash_commands(cx: &mut App) {
+fn register_slash_commands(prompt_builder: Option<Arc<PromptBuilder>>, cx: &mut App) {
     let slash_command_registry = SlashCommandRegistry::global(cx);
 
     slash_command_registry.register_command(assistant_slash_commands::FileSlashCommand, true);
@@ -248,6 +227,21 @@ fn register_slash_commands(cx: &mut App) {
         .register_command(assistant_slash_commands::DiagnosticsSlashCommand, true);
     slash_command_registry.register_command(assistant_slash_commands::FetchSlashCommand, true);
 
+    if let Some(prompt_builder) = prompt_builder {
+        cx.observe_flag::<assistant_slash_commands::ProjectSlashCommandFeatureFlag, _>({
+            let slash_command_registry = slash_command_registry.clone();
+            move |is_enabled, _cx| {
+                if is_enabled {
+                    slash_command_registry.register_command(
+                        assistant_slash_commands::ProjectSlashCommand::new(prompt_builder.clone()),
+                        true,
+                    );
+                }
+            }
+        })
+        .detach();
+    }
+
     cx.observe_flag::<assistant_slash_commands::StreamingExampleSlashCommandFeatureFlag, _>({
         let slash_command_registry = slash_command_registry.clone();
         move |is_enabled, _cx| {
@@ -264,6 +258,17 @@ fn register_slash_commands(cx: &mut App) {
     update_slash_commands_from_settings(cx);
     cx.observe_global::<SettingsStore>(update_slash_commands_from_settings)
         .detach();
+
+    cx.observe_flag::<assistant_slash_commands::SearchSlashCommandFeatureFlag, _>({
+        let slash_command_registry = slash_command_registry.clone();
+        move |is_enabled, _cx| {
+            if is_enabled {
+                slash_command_registry
+                    .register_command(assistant_slash_commands::SearchSlashCommand, true);
+            }
+        }
+    })
+    .detach();
 }
 
 fn update_slash_commands_from_settings(cx: &mut App) {

crates/assistant/src/assistant_configuration.rs

@@ -1,9 +1,9 @@
 use std::sync::Arc;
 
 use collections::HashMap;
-use gpui::{AnyView, App, EventEmitter, FocusHandle, Focusable, Subscription, canvas};
+use gpui::{canvas, AnyView, App, EventEmitter, FocusHandle, Focusable, Subscription};
 use language_model::{LanguageModelProvider, LanguageModelProviderId, LanguageModelRegistry};
-use ui::{ElevationIndex, prelude::*};
+use ui::{prelude::*, ElevationIndex};
 use workspace::Item;
 
 pub struct ConfigurationView {

crates/assistant/src/assistant_panel.rs

@@ -1,45 +1,42 @@
-use crate::Assistant;
 use crate::assistant_configuration::{ConfigurationView, ConfigurationViewEvent};
 use crate::{
-    DeployHistory, InlineAssistant, NewChat, terminal_inline_assistant::TerminalInlineAssistant,
+    terminal_inline_assistant::TerminalInlineAssistant, DeployHistory, InlineAssistant, NewChat,
 };
-use anyhow::{Result, anyhow};
+use anyhow::{anyhow, Result};
 use assistant_context_editor::{
-    AssistantContext, AssistantPanelDelegate, ContextEditor, ContextEditorToolbarItem,
-    ContextEditorToolbarItemEvent, ContextHistory, ContextId, ContextStore, ContextStoreEvent,
-    DEFAULT_TAB_TITLE, InsertDraggedFiles, SlashCommandCompletionProvider,
-    make_lsp_adapter_delegate,
+    make_lsp_adapter_delegate, AssistantContext, AssistantPanelDelegate, ContextEditor,
+    ContextEditorToolbarItem, ContextEditorToolbarItemEvent, ContextHistory, ContextId,
+    ContextStore, ContextStoreEvent, InsertDraggedFiles, SlashCommandCompletionProvider,
+    DEFAULT_TAB_TITLE,
 };
 use assistant_settings::{AssistantDockPosition, AssistantSettings};
 use assistant_slash_command::SlashCommandWorkingSet;
-use client::{Client, Status, proto};
+use client::{proto, Client, Status};
 use editor::{Editor, EditorEvent};
 use fs::Fs;
 use gpui::{
-    Action, App, AsyncWindowContext, Entity, EventEmitter, ExternalPaths, FocusHandle, Focusable,
-    InteractiveElement, IntoElement, ParentElement, Pixels, Render, Styled, Subscription, Task,
-    UpdateGlobal, WeakEntity, prelude::*,
+    prelude::*, Action, App, AsyncWindowContext, Entity, EventEmitter, ExternalPaths, FocusHandle,
+    Focusable, InteractiveElement, IntoElement, ParentElement, Pixels, Render, Styled,
+    Subscription, Task, UpdateGlobal, WeakEntity,
 };
 use language::LanguageRegistry;
 use language_model::{
-    AuthenticateError, ConfiguredModel, LanguageModelProviderId, LanguageModelRegistry,
-    ZED_CLOUD_PROVIDER_ID,
+    AuthenticateError, LanguageModelProviderId, LanguageModelRegistry, ZED_CLOUD_PROVIDER_ID,
 };
 use project::Project;
-use prompt_library::{PromptLibrary, open_prompt_library};
+use prompt_library::{open_prompt_library, PromptLibrary};
 use prompt_store::PromptBuilder;
-use search::{BufferSearchBar, buffer_search::DivRegistrar};
-use settings::{Settings, update_settings_file};
+use search::{buffer_search::DivRegistrar, BufferSearchBar};
+use settings::{update_settings_file, Settings};
 use smol::stream::StreamExt;
 use std::{ops::ControlFlow, path::PathBuf, sync::Arc};
-use terminal_view::{TerminalView, terminal_panel::TerminalPanel};
-use ui::{ContextMenu, PopoverMenu, Tooltip, prelude::*};
-use util::{ResultExt, maybe};
+use terminal_view::{terminal_panel::TerminalPanel, TerminalView};
+use ui::{prelude::*, ContextMenu, PopoverMenu, Tooltip};
+use util::{maybe, ResultExt};
 use workspace::DraggedTab;
 use workspace::{
-    DraggedSelection, Pane, ShowConfiguration, ToggleZoom, Workspace,
     dock::{DockPosition, Panel, PanelEvent},
-    pane,
+    pane, DraggedSelection, Pane, ShowConfiguration, ToggleZoom, Workspace,
 };
 use zed_actions::assistant::{InlineAssist, OpenPromptLibrary, ToggleFocus};
 
@@ -61,7 +58,8 @@ pub fn init(cx: &mut App) {
 
     cx.observe_new(
         |terminal_panel: &mut TerminalPanel, _, cx: &mut Context<TerminalPanel>| {
-            terminal_panel.set_assistant_enabled(Assistant::enabled(cx), cx);
+            let settings = AssistantSettings::get_global(cx);
+            terminal_panel.set_assistant_enabled(settings.enabled, cx);
         },
     )
     .detach();
@@ -299,10 +297,8 @@ impl AssistantPanel {
                 &LanguageModelRegistry::global(cx),
                 window,
                 |this, _, event: &language_model::Event, window, cx| match event {
-                    language_model::Event::DefaultModelChanged
-                    | language_model::Event::InlineAssistantModelChanged
-                    | language_model::Event::CommitMessageModelChanged
-                    | language_model::Event::ThreadSummaryModelChanged => {
+                    language_model::Event::ActiveModelChanged
+                    | language_model::Event::EditorModelChanged => {
                         this.completion_provider_changed(window, cx);
                     }
                     language_model::Event::ProviderStateChanged => {
@@ -346,12 +342,12 @@ impl AssistantPanel {
         window: &mut Window,
         cx: &mut Context<Workspace>,
     ) {
-        if workspace
-            .panel::<Self>(cx)
-            .is_some_and(|panel| panel.read(cx).enabled(cx))
-        {
-            workspace.toggle_panel_focus::<Self>(window, cx);
+        let settings = AssistantSettings::get_global(cx);
+        if !settings.enabled {
+            return;
         }
+
+        workspace.toggle_panel_focus::<Self>(window, cx);
     }
 
     fn watch_client_status(
@@ -471,12 +467,12 @@ impl AssistantPanel {
     }
 
     fn update_zed_ai_notice_visibility(&mut self, client_status: Status, cx: &mut Context<Self>) {
-        let model = LanguageModelRegistry::read_global(cx).default_model();
+        let active_provider = LanguageModelRegistry::read_global(cx).active_provider();
 
         // 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()
-            && model.map_or(true, |model| model.provider.id().0 == ZED_CLOUD_PROVIDER_ID);
+            && active_provider.map_or(true, |provider| provider.id().0 == ZED_CLOUD_PROVIDER_ID);
 
         self.show_zed_ai_notice = show_zed_ai_notice;
         cx.notify();
@@ -544,8 +540,8 @@ impl AssistantPanel {
         }
 
         let Some(new_provider_id) = LanguageModelRegistry::read_global(cx)
-            .default_model()
-            .map(|default| default.provider.id())
+            .active_provider()
+            .map(|p| p.id())
         else {
             return;
         };
@@ -571,9 +567,7 @@ impl AssistantPanel {
             return;
         }
 
-        let Some(ConfiguredModel { provider, .. }) =
-            LanguageModelRegistry::read_global(cx).default_model()
-        else {
+        let Some(provider) = LanguageModelRegistry::read_global(cx).active_provider() else {
             return;
         };
 
@@ -601,10 +595,12 @@ impl AssistantPanel {
         window: &mut Window,
         cx: &mut Context<Workspace>,
     ) {
-        let Some(assistant_panel) = workspace
-            .panel::<AssistantPanel>(cx)
-            .filter(|panel| panel.read(cx).enabled(cx))
-        else {
+        let settings = AssistantSettings::get_global(cx);
+        if !settings.enabled {
+            return;
+        }
+
+        let Some(assistant_panel) = workspace.panel::<AssistantPanel>(cx) else {
             return;
         };
 
@@ -981,8 +977,8 @@ impl AssistantPanel {
                 |this, _, event: &ConfigurationViewEvent, window, cx| match event {
                     ConfigurationViewEvent::NewProviderContextEditor(provider) => {
                         if LanguageModelRegistry::read_global(cx)
-                            .default_model()
-                            .map_or(true, |default| default.provider.id() != provider.id())
+                            .active_provider()
+                            .map_or(true, |p| p.id() != provider.id())
                         {
                             if let Some(model) = provider.default_model(cx) {
                                 update_settings_file::<AssistantSettings>(
@@ -1160,8 +1156,8 @@ impl AssistantPanel {
 
     fn is_authenticated(&mut self, cx: &mut Context<Self>) -> bool {
         LanguageModelRegistry::read_global(cx)
-            .default_model()
-            .map_or(false, |default| default.provider.is_authenticated(cx))
+            .active_provider()
+            .map_or(false, |provider| provider.is_authenticated(cx))
     }
 
     fn authenticate(
@@ -1169,8 +1165,8 @@ impl AssistantPanel {
         cx: &mut Context<Self>,
     ) -> Option<Task<Result<(), AuthenticateError>>> {
         LanguageModelRegistry::read_global(cx)
-            .default_model()
-            .map_or(None, |default| Some(default.provider.authenticate(cx)))
+            .active_provider()
+            .map_or(None, |provider| Some(provider.authenticate(cx)))
     }
 
     fn restart_context_servers(
@@ -1302,8 +1298,12 @@ impl Panel for AssistantPanel {
     }
 
     fn icon(&self, _: &Window, cx: &App) -> Option<IconName> {
-        (self.enabled(cx) && AssistantSettings::get_global(cx).button)
-            .then_some(IconName::ZedAssistant)
+        let settings = AssistantSettings::get_global(cx);
+        if !settings.enabled || !settings.button {
+            return None;
+        }
+
+        Some(IconName::ZedAssistant)
     }
 
     fn icon_tooltip(&self, _: &Window, _: &App) -> Option<&'static str> {
@@ -1317,10 +1317,6 @@ impl Panel for AssistantPanel {
     fn activation_priority(&self) -> u32 {
         4
     }
-
-    fn enabled(&self, cx: &App) -> bool {
-        Assistant::enabled(cx)
-    }
 }
 
 impl EventEmitter<PanelEvent> for AssistantPanel {}

crates/assistant/src/inline_assistant.rs

@@ -1,41 +1,39 @@
 use crate::{
-    Assistant, AssistantPanel, AssistantPanelEvent, CycleNextInlineAssist,
-    CyclePreviousInlineAssist,
+    AssistantPanel, AssistantPanelEvent, CycleNextInlineAssist, CyclePreviousInlineAssist,
 };
-use anyhow::{Context as _, Result, anyhow};
-use assistant_context_editor::{RequestType, humanize_token_count};
+use anyhow::{anyhow, Context as _, Result};
+use assistant_context_editor::{humanize_token_count, RequestType};
 use assistant_settings::AssistantSettings;
-use client::{ErrorExt, telemetry::Telemetry};
-use collections::{HashMap, HashSet, VecDeque, hash_map};
+use client::{telemetry::Telemetry, ErrorExt};
+use collections::{hash_map, HashMap, HashSet, VecDeque};
 use editor::{
-    Anchor, AnchorRangeExt, CodeActionProvider, Editor, EditorElement, EditorEvent, EditorMode,
-    EditorStyle, ExcerptId, ExcerptRange, GutterDimensions, MultiBuffer, MultiBufferSnapshot,
-    ToOffset as _, ToPoint,
     actions::{MoveDown, MoveUp, SelectAll},
     display_map::{
         BlockContext, BlockPlacement, BlockProperties, BlockStyle, CustomBlockId, RenderBlock,
         ToDisplayPoint,
     },
+    Anchor, AnchorRangeExt, CodeActionProvider, Editor, EditorElement, EditorEvent, EditorMode,
+    EditorStyle, ExcerptId, ExcerptRange, GutterDimensions, MultiBuffer, MultiBufferSnapshot,
+    ToOffset as _, ToPoint,
 };
 use feature_flags::{
     Assistant2FeatureFlag, FeatureFlagAppExt as _, FeatureFlagViewExt as _, ZedPro,
 };
 use fs::Fs;
 use futures::{
-    SinkExt, Stream, StreamExt,
     channel::mpsc,
     future::{BoxFuture, LocalBoxFuture},
-    join,
+    join, SinkExt, Stream, StreamExt,
 };
 use gpui::{
-    AnyElement, App, ClickEvent, Context, CursorStyle, Entity, EventEmitter, FocusHandle,
-    Focusable, FontWeight, Global, HighlightStyle, Subscription, Task, TextStyle, UpdateGlobal,
-    WeakEntity, Window, anchored, deferred, point,
+    anchored, deferred, point, AnyElement, App, ClickEvent, Context, CursorStyle, Entity,
+    EventEmitter, FocusHandle, Focusable, FontWeight, Global, HighlightStyle, Subscription, Task,
+    TextStyle, UpdateGlobal, WeakEntity, Window,
 };
-use language::{Buffer, IndentKind, Point, Selection, TransactionId, line_diff};
+use language::{line_diff, Buffer, IndentKind, Point, Selection, TransactionId};
 use language_model::{
-    ConfiguredModel, LanguageModel, LanguageModelRegistry, LanguageModelRequest,
-    LanguageModelRequestMessage, LanguageModelTextStream, Role, report_assistant_event,
+    report_assistant_event, LanguageModel, LanguageModelRegistry, LanguageModelRequest,
+    LanguageModelRequestMessage, LanguageModelTextStream, Role,
 };
 use language_model_selector::{LanguageModelSelector, LanguageModelSelectorPopoverMenu};
 use multi_buffer::MultiBufferRow;
@@ -43,7 +41,7 @@ use parking_lot::Mutex;
 use project::{CodeAction, LspAction, ProjectTransaction};
 use prompt_store::PromptBuilder;
 use rope::Rope;
-use settings::{Settings, SettingsStore, update_settings_file};
+use settings::{update_settings_file, Settings, SettingsStore};
 use smol::future::FutureExt;
 use std::{
     cmp,
@@ -62,10 +60,10 @@ use terminal_view::terminal_panel::TerminalPanel;
 use text::{OffsetRangeExt, ToPoint as _};
 use theme::ThemeSettings;
 use ui::{
-    CheckboxWithLabel, IconButtonShape, KeyBinding, Popover, Tooltip, prelude::*, text_for_action,
+    prelude::*, text_for_action, CheckboxWithLabel, IconButtonShape, KeyBinding, Popover, Tooltip,
 };
 use util::{RangeExt, ResultExt};
-use workspace::{ItemHandle, Toast, Workspace, notifications::NotificationId};
+use workspace::{notifications::NotificationId, ItemHandle, Toast, Workspace};
 
 pub fn init(
     fs: Arc<dyn Fs>,
@@ -312,9 +310,7 @@ impl InlineAssistant {
                 start..end,
             ));
 
-            if let Some(ConfiguredModel { model, .. }) =
-                LanguageModelRegistry::read_global(cx).default_model()
-            {
+            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
                 self.telemetry.report_assistant_event(AssistantEvent {
                     conversation_id: None,
                     kind: AssistantKind::Inline,
@@ -879,9 +875,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(ConfiguredModel { model, .. }) =
-                LanguageModelRegistry::read_global(cx).default_model()
-            {
+            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
                 let language_name = assist.editor.upgrade().and_then(|editor| {
                     let multibuffer = editor.read(cx).buffer().read(cx);
                     let multibuffer_snapshot = multibuffer.snapshot(cx);
@@ -1274,7 +1268,10 @@ impl InlineAssistant {
                     multi_buffer.update(cx, |multi_buffer, cx| {
                         multi_buffer.push_excerpts(
                             old_buffer.clone(),
-                            Some(ExcerptRange::new(buffer_start..buffer_end)),
+                            Some(ExcerptRange {
+                                context: buffer_start..buffer_end,
+                                primary: None,
+                            }),
                             cx,
                         );
                     });
@@ -1633,8 +1630,8 @@ impl Render for PromptEditor {
                                 format!(
                                     "Using {}",
                                     LanguageModelRegistry::read_global(cx)
-                                        .default_model()
-                                        .map(|default| default.model.name().0)
+                                        .active_model()
+                                        .map(|model| model.name().0)
                                         .unwrap_or_else(|| "No model selected".into()),
                                 ),
                                 None,
@@ -2081,7 +2078,7 @@ impl PromptEditor {
         let disabled = matches!(codegen.status(cx), CodegenStatus::Idle);
 
         let model_registry = LanguageModelRegistry::read_global(cx);
-        let default_model = model_registry.default_model().map(|default| default.model);
+        let default_model = model_registry.active_model();
         let alternative_models = model_registry.inline_alternative_models();
 
         let get_model_name = |index: usize| -> String {
@@ -2187,9 +2184,7 @@ impl PromptEditor {
     }
 
     fn render_token_count(&self, cx: &mut Context<Self>) -> Option<impl IntoElement> {
-        let model = LanguageModelRegistry::read_global(cx)
-            .default_model()?
-            .model;
+        let model = LanguageModelRegistry::read_global(cx).active_model()?;
         let token_counts = self.token_counts?;
         let max_token_count = model.max_token_count();
 
@@ -2644,9 +2639,8 @@ impl Codegen {
         }
 
         let primary_model = LanguageModelRegistry::read_global(cx)
-            .default_model()
-            .context("no active model")?
-            .model;
+            .active_model()
+            .context("no active model")?;
 
         for (model, alternative) in iter::once(primary_model)
             .chain(alternative_models)
@@ -2870,9 +2864,7 @@ impl CodegenAlternative {
         assistant_panel_context: Option<LanguageModelRequest>,
         cx: &App,
     ) -> BoxFuture<'static, Result<TokenCounts>> {
-        if let Some(ConfiguredModel { model, .. }) =
-            LanguageModelRegistry::read_global(cx).inline_assistant_model()
-        {
+        if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
             let request = self.build_request(user_prompt, assistant_panel_context.clone(), cx);
             match request {
                 Ok(request) => {
@@ -3563,7 +3555,7 @@ impl CodeActionProvider for AssistantCodeActionProvider {
         _: &mut Window,
         cx: &mut App,
     ) -> Task<Result<Vec<CodeAction>>> {
-        if !Assistant::enabled(cx) {
+        if !AssistantSettings::get_global(cx).enabled {
             return Task::ready(Ok(Vec::new()));
         }
 
@@ -3717,8 +3709,8 @@ mod tests {
     use gpui::TestAppContext;
     use indoc::indoc;
     use language::{
-        Buffer, Language, LanguageConfig, LanguageMatcher, Point, language_settings,
-        tree_sitter_rust,
+        language_settings, tree_sitter_rust, Buffer, Language, LanguageConfig, LanguageMatcher,
+        Point,
     };
     use language_model::{LanguageModelRegistry, TokenUsage};
     use rand::prelude::*;

crates/assistant/src/terminal_inline_assistant.rs

@@ -1,27 +1,27 @@
 use crate::{AssistantPanel, AssistantPanelEvent, DEFAULT_CONTEXT_LINES};
 use anyhow::{Context as _, Result};
-use assistant_context_editor::{RequestType, humanize_token_count};
+use assistant_context_editor::{humanize_token_count, RequestType};
 use assistant_settings::AssistantSettings;
 use client::telemetry::Telemetry;
 use collections::{HashMap, VecDeque};
 use editor::{
-    Editor, EditorElement, EditorEvent, EditorMode, EditorStyle, MultiBuffer,
     actions::{MoveDown, MoveUp, SelectAll},
+    Editor, EditorElement, EditorEvent, EditorMode, EditorStyle, MultiBuffer,
 };
 use fs::Fs;
-use futures::{SinkExt, StreamExt, channel::mpsc};
+use futures::{channel::mpsc, SinkExt, StreamExt};
 use gpui::{
     App, Context, Entity, EventEmitter, FocusHandle, Focusable, Global, Subscription, Task,
     TextStyle, UpdateGlobal, WeakEntity,
 };
 use language::Buffer;
 use language_model::{
-    ConfiguredModel, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage,
-    Role, report_assistant_event,
+    report_assistant_event, LanguageModelRegistry, LanguageModelRequest,
+    LanguageModelRequestMessage, Role,
 };
 use language_model_selector::{LanguageModelSelector, LanguageModelSelectorPopoverMenu};
 use prompt_store::PromptBuilder;
-use settings::{Settings, update_settings_file};
+use settings::{update_settings_file, Settings};
 use std::{
     cmp,
     sync::Arc,
@@ -31,9 +31,9 @@ use telemetry_events::{AssistantEvent, AssistantKind, AssistantPhase};
 use terminal::Terminal;
 use terminal_view::TerminalView;
 use theme::ThemeSettings;
-use ui::{IconButtonShape, Tooltip, prelude::*, text_for_action};
+use ui::{prelude::*, text_for_action, IconButtonShape, Tooltip};
 use util::ResultExt;
-use workspace::{Toast, Workspace, notifications::NotificationId};
+use workspace::{notifications::NotificationId, Toast, Workspace};
 
 pub fn init(
     fs: Arc<dyn Fs>,
@@ -318,9 +318,7 @@ impl TerminalInlineAssistant {
                 })
                 .log_err();
 
-            if let Some(ConfiguredModel { model, .. }) =
-                LanguageModelRegistry::read_global(cx).inline_assistant_model()
-            {
+            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
                 let codegen = assist.codegen.read(cx);
                 let executor = cx.background_executor().clone();
                 report_assistant_event(
@@ -654,8 +652,8 @@ impl Render for PromptEditor {
                                 format!(
                                     "Using {}",
                                     LanguageModelRegistry::read_global(cx)
-                                        .inline_assistant_model()
-                                        .map(|inline_assistant| inline_assistant.model.name().0)
+                                        .active_model()
+                                        .map(|model| model.name().0)
                                         .unwrap_or_else(|| "No model selected".into()),
                                 ),
                                 None,
@@ -824,9 +822,7 @@ impl PromptEditor {
 
     fn count_tokens(&mut self, cx: &mut Context<Self>) {
         let assist_id = self.id;
-        let Some(ConfiguredModel { model, .. }) =
-            LanguageModelRegistry::read_global(cx).inline_assistant_model()
-        else {
+        let Some(model) = LanguageModelRegistry::read_global(cx).active_model() else {
             return;
         };
         self.pending_token_count = cx.spawn(async move |this, cx| {
@@ -984,9 +980,7 @@ impl PromptEditor {
     }
 
     fn render_token_count(&self, cx: &mut Context<Self>) -> Option<impl IntoElement> {
-        let model = LanguageModelRegistry::read_global(cx)
-            .inline_assistant_model()?
-            .model;
+        let model = LanguageModelRegistry::read_global(cx).active_model()?;
         let token_count = self.token_count?;
         let max_token_count = model.max_token_count();
 
@@ -1137,9 +1131,7 @@ impl Codegen {
     }
 
     pub fn start(&mut self, prompt: LanguageModelRequest, cx: &mut Context<Self>) {
-        let Some(ConfiguredModel { model, .. }) =
-            LanguageModelRegistry::read_global(cx).inline_assistant_model()
-        else {
+        let Some(model) = LanguageModelRegistry::read_global(cx).active_model() else {
             return;
         };
 

crates/assistant2/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "agent"
+name = "assistant2"
 version = "0.1.0"
 edition.workspace = true
 publish.workspace = true
@@ -25,14 +25,12 @@ assistant_settings.workspace = true
 assistant_slash_command.workspace = true
 assistant_tool.workspace = true
 async-watch.workspace = true
-buffer_diff.workspace = true
 chrono.workspace = true
 client.workspace = true
 clock.workspace = true
 collections.workspace = true
 command_palette_hooks.workspace = true
 context_server.workspace = true
-convert_case.workspace = true
 db.workspace = true
 editor.workspace = true
 feature_flags.workspace = true
@@ -41,6 +39,7 @@ fs.workspace = true
 futures.workspace = true
 fuzzy.workspace = true
 git.workspace = true
+git_ui.workspace = true
 gpui.workspace = true
 heed.workspace = true
 html_to_markdown.workspace = true
@@ -55,7 +54,6 @@ lsp.workspace = true
 markdown.workspace = true
 menu.workspace = true
 multi_buffer.workspace = true
-ordered-float.workspace = true
 parking_lot.workspace = true
 paths.workspace = true
 picker.workspace = true
@@ -65,7 +63,6 @@ prompt_store.workspace = true
 proto.workspace = true
 release_channel.workspace = true
 rope.workspace = true
-schemars.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 settings.workspace = true
@@ -81,16 +78,13 @@ theme.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.workspace = true
 zed_actions.workspace = true
-workspace-hack.workspace = true
 
 [dev-dependencies]
-buffer_diff = { workspace = true, features = ["test-support"] }
 editor = { workspace = true, features = ["test-support"] }
 gpui = { workspace = true, "features" = ["test-support"] }
 indoc.workspace = true

crates/assistant2/src/assistant.rs

@@ -1,5 +1,4 @@
 mod active_thread;
-mod agent_diff;
 mod assistant_configuration;
 mod assistant_model_selector;
 mod assistant_panel;
@@ -23,17 +22,14 @@ mod ui;
 
 use std::sync::Arc;
 
-use assistant_settings::{AgentProfileId, AssistantSettings};
+use assistant_settings::AssistantSettings;
 use client::Client;
 use command_palette_hooks::CommandPaletteFilter;
 use feature_flags::{Assistant2FeatureFlag, FeatureFlagAppExt};
 use fs::Fs;
-use gpui::{App, actions, impl_actions};
+use gpui::{actions, App};
 use prompt_store::PromptBuilder;
-use schemars::JsonSchema;
-use serde::Deserialize;
 use settings::Settings as _;
-use thread::ThreadId;
 
 pub use crate::active_thread::ActiveThread;
 use crate::assistant_configuration::{AddContextServerModal, ManageProfilesModal};
@@ -41,17 +37,17 @@ pub use crate::assistant_panel::{AssistantPanel, ConcreteAssistantPanelDelegate}
 pub use crate::inline_assistant::InlineAssistant;
 pub use crate::thread::{Message, RequestKind, Thread, ThreadEvent};
 pub use crate::thread_store::ThreadStore;
-pub use agent_diff::{AgentDiff, AgentDiffToolbar};
 
 actions!(
-    agent,
+    assistant2,
     [
+        NewThread,
         NewPromptEditor,
         ToggleContextPicker,
-        ToggleProfileSelector,
         RemoveAllContext,
         OpenHistory,
         OpenConfiguration,
+        ManageProfiles,
         AddContextServer,
         RemoveSelectedThread,
         Chat,
@@ -64,40 +60,13 @@ actions!(
         FocusRight,
         RemoveFocusedContext,
         AcceptSuggestedContext,
-        OpenActiveThreadAsMarkdown,
-        OpenAgentDiff,
-        Keep,
-        Reject,
-        RejectAll,
-        KeepAll
+        OpenActiveThreadAsMarkdown
     ]
 );
 
-#[derive(Default, Clone, PartialEq, Deserialize, JsonSchema)]
-pub struct NewThread {
-    #[serde(default)]
-    from_thread_id: Option<ThreadId>,
-}
+const NAMESPACE: &str = "assistant2";
 
-#[derive(PartialEq, Clone, Default, Debug, Deserialize, JsonSchema)]
-pub struct ManageProfiles {
-    #[serde(default)]
-    pub customize_tools: Option<AgentProfileId>,
-}
-
-impl ManageProfiles {
-    pub fn customize_tools(profile_id: AgentProfileId) -> Self {
-        Self {
-            customize_tools: Some(profile_id),
-        }
-    }
-}
-
-impl_actions!(agent, [NewThread, ManageProfiles]);
-
-const NAMESPACE: &str = "agent";
-
-/// Initializes the `agent` crate.
+/// Initializes the `assistant2` crate.
 pub fn init(
     fs: Arc<dyn Fs>,
     client: Arc<Client>,
@@ -123,10 +92,10 @@ pub fn init(
     cx.observe_new(AddContextServerModal::register).detach();
     cx.observe_new(ManageProfilesModal::register).detach();
 
-    feature_gate_agent_actions(cx);
+    feature_gate_assistant2_actions(cx);
 }
 
-fn feature_gate_agent_actions(cx: &mut App) {
+fn feature_gate_assistant2_actions(cx: &mut App) {
     CommandPaletteFilter::update_global(cx, |filter, _cx| {
         filter.hide_namespace(NAMESPACE);
     });

crates/assistant2/src/assistant_configuration.rs

@@ -1,18 +1,16 @@
 mod add_context_server_modal;
 mod manage_profiles_modal;
+mod profile_picker;
 mod tool_picker;
 
 use std::sync::Arc;
 
-use assistant_settings::AssistantSettings;
 use assistant_tool::{ToolSource, ToolWorkingSet};
 use collections::HashMap;
 use context_server::manager::ContextServerManager;
-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::{prelude::*, Disclosure, Divider, DividerColor, ElevationIndex, Indicator, Switch};
 use util::ResultExt as _;
 use zed_actions::ExtensionCategoryFilter;
 
@@ -22,7 +20,6 @@ pub(crate) use manage_profiles_modal::ManageProfilesModal;
 use crate::AddContextServer;
 
 pub struct AssistantConfiguration {
-    fs: Arc<dyn Fs>,
     focus_handle: FocusHandle,
     configuration_views_by_provider: HashMap<LanguageModelProviderId, AnyView>,
     context_server_manager: Entity<ContextServerManager>,
@@ -33,7 +30,6 @@ pub struct AssistantConfiguration {
 
 impl AssistantConfiguration {
     pub fn new(
-        fs: Arc<dyn Fs>,
         context_server_manager: Entity<ContextServerManager>,
         tools: Arc<ToolWorkingSet>,
         window: &mut Window,
@@ -59,7 +55,6 @@ impl AssistantConfiguration {
         );
 
         let mut this = Self {
-            fs,
             focus_handle,
             configuration_views_by_provider: HashMap::default(),
             context_server_manager,
@@ -111,7 +106,7 @@ impl AssistantConfiguration {
         &mut self,
         provider: &Arc<dyn LanguageModelProvider>,
         cx: &mut Context<Self>,
-    ) -> impl IntoElement + use<> {
+    ) -> impl IntoElement {
         let provider_id = provider.id().0.clone();
         let provider_name = provider.name().0.clone();
         let configuration_view = self
@@ -173,55 +168,6 @@ impl AssistantConfiguration {
             )
     }
 
-    fn render_command_permission(&mut self, cx: &mut Context<Self>) -> impl IntoElement {
-        let always_allow_tool_actions = AssistantSettings::get_global(cx).always_allow_tool_actions;
-
-        const HEADING: &str = "Allow running tools without asking for confirmation";
-
-        v_flex()
-            .p(DynamicSpacing::Base16.rems(cx))
-            .gap_2()
-            .flex_1()
-            .child(Headline::new("General Settings").size(HeadlineSize::Small))
-            .child(
-                h_flex()
-                    .p_2p5()
-                    .rounded_sm()
-                    .bg(cx.theme().colors().editor_background)
-                    .border_1()
-                    .border_color(cx.theme().colors().border)
-                    .gap_4()
-                    .justify_between()
-                    .flex_wrap()
-                    .child(
-                        v_flex()
-                            .gap_0p5()
-                            .max_w_5_6()
-                            .child(Label::new(HEADING))
-                            .child(Label::new("When enabled, the agent can perform potentially destructive actions without asking for your confirmation.").color(Color::Muted)),
-                    )
-                    .child(
-                        Switch::new(
-                            "always-allow-tool-actions-switch",
-                            always_allow_tool_actions.into(),
-                        )
-                        .on_click({
-                            let fs = self.fs.clone();
-                            move |state, _window, cx| {
-                                let allow = state == &ToggleState::Selected;
-                                update_settings_file::<AssistantSettings>(
-                                    fs.clone(),
-                                    cx,
-                                    move |settings, _| {
-                                        settings.set_always_allow_tool_actions(allow);
-                                    },
-                                );
-                            }
-                        }),
-                    ),
-            )
-    }
-
     fn render_context_servers_section(&mut self, cx: &mut Context<Self>) -> impl IntoElement {
         let context_servers = self.context_server_manager.read(cx).all_servers().clone();
         let tools_by_source = self.tools.tools_by_source(cx);
@@ -413,8 +359,6 @@ impl Render for AssistantConfiguration {
             .bg(cx.theme().colors().panel_background)
             .size_full()
             .overflow_y_scroll()
-            .child(self.render_command_permission(cx))
-            .child(Divider::horizontal().color(DividerColor::Border))
             .child(self.render_context_servers_section(cx))
             .child(Divider::horizontal().color(DividerColor::Border))
             .child(

crates/assistant2/src/assistant_configuration/add_context_server_modal.rs

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

crates/assistant2/src/assistant_configuration/manage_profiles_modal.rs

@@ -0,0 +1,250 @@
+use std::sync::Arc;
+
+use assistant_settings::AssistantSettings;
+use assistant_tool::ToolWorkingSet;
+use fs::Fs;
+use gpui::{prelude::*, DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, Subscription};
+use settings::Settings as _;
+use ui::{prelude::*, ListItem, ListItemSpacing, Navigable, NavigableEntry};
+use workspace::{ModalView, Workspace};
+
+use crate::assistant_configuration::profile_picker::{ProfilePicker, ProfilePickerDelegate};
+use crate::assistant_configuration::tool_picker::{ToolPicker, ToolPickerDelegate};
+use crate::{AssistantPanel, ManageProfiles};
+
+enum Mode {
+    ChooseProfile {
+        profile_picker: Entity<ProfilePicker>,
+        _subscription: Subscription,
+    },
+    ViewProfile(ViewProfileMode),
+    ConfigureTools {
+        tool_picker: Entity<ToolPicker>,
+        _subscription: Subscription,
+    },
+}
+
+impl Mode {
+    pub fn choose_profile(window: &mut Window, cx: &mut Context<ManageProfilesModal>) -> Self {
+        let this = cx.entity();
+
+        let profile_picker = cx.new(|cx| {
+            let delegate = ProfilePickerDelegate::new(
+                move |profile_id, window, cx| {
+                    this.update(cx, |this, cx| {
+                        this.view_profile(profile_id.clone(), window, cx);
+                    })
+                },
+                cx,
+            );
+            ProfilePicker::new(delegate, window, cx)
+        });
+        let dismiss_subscription = cx.subscribe_in(
+            &profile_picker,
+            window,
+            |_this, _profile_picker, _: &DismissEvent, _window, cx| {
+                cx.emit(DismissEvent);
+            },
+        );
+
+        Self::ChooseProfile {
+            profile_picker,
+            _subscription: dismiss_subscription,
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct ViewProfileMode {
+    profile_id: Arc<str>,
+    configure_tools: NavigableEntry,
+}
+
+pub struct ManageProfilesModal {
+    fs: Arc<dyn Fs>,
+    tools: Arc<ToolWorkingSet>,
+    focus_handle: FocusHandle,
+    mode: Mode,
+}
+
+impl ManageProfilesModal {
+    pub fn register(
+        workspace: &mut Workspace,
+        _window: Option<&mut Window>,
+        _cx: &mut Context<Workspace>,
+    ) {
+        workspace.register_action(|workspace, _: &ManageProfiles, window, cx| {
+            if let Some(panel) = workspace.panel::<AssistantPanel>(cx) {
+                let fs = workspace.app_state().fs.clone();
+                let thread_store = panel.read(cx).thread_store().read(cx);
+                let tools = thread_store.tools();
+                workspace.toggle_modal(window, cx, |window, cx| Self::new(fs, tools, window, cx))
+            }
+        });
+    }
+
+    pub fn new(
+        fs: Arc<dyn Fs>,
+        tools: Arc<ToolWorkingSet>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let focus_handle = cx.focus_handle();
+
+        Self {
+            fs,
+            tools,
+            focus_handle,
+            mode: Mode::choose_profile(window, cx),
+        }
+    }
+
+    fn choose_profile(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        self.mode = Mode::choose_profile(window, cx);
+        self.focus_handle(cx).focus(window);
+    }
+
+    pub fn view_profile(
+        &mut self,
+        profile_id: Arc<str>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.mode = Mode::ViewProfile(ViewProfileMode {
+            profile_id,
+            configure_tools: NavigableEntry::focusable(cx),
+        });
+        self.focus_handle(cx).focus(window);
+    }
+
+    fn configure_tools(
+        &mut self,
+        profile_id: Arc<str>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let settings = AssistantSettings::get_global(cx);
+        let Some(profile) = settings.profiles.get(&profile_id).cloned() else {
+            return;
+        };
+
+        let tool_picker = cx.new(|cx| {
+            let delegate = ToolPickerDelegate::new(
+                self.fs.clone(),
+                self.tools.clone(),
+                profile_id.clone(),
+                profile,
+                cx,
+            );
+            ToolPicker::new(delegate, window, cx)
+        });
+        let dismiss_subscription = cx.subscribe_in(&tool_picker, window, {
+            let profile_id = profile_id.clone();
+            move |this, _tool_picker, _: &DismissEvent, window, cx| {
+                this.view_profile(profile_id.clone(), window, cx);
+            }
+        });
+
+        self.mode = Mode::ConfigureTools {
+            tool_picker,
+            _subscription: dismiss_subscription,
+        };
+        self.focus_handle(cx).focus(window);
+    }
+
+    fn confirm(&mut self, _window: &mut Window, _cx: &mut Context<Self>) {}
+
+    fn cancel(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        match &self.mode {
+            Mode::ChooseProfile { .. } => {}
+            Mode::ViewProfile(_) => self.choose_profile(window, cx),
+            Mode::ConfigureTools { .. } => {}
+        }
+    }
+}
+
+impl ModalView for ManageProfilesModal {}
+
+impl Focusable for ManageProfilesModal {
+    fn focus_handle(&self, cx: &App) -> FocusHandle {
+        match &self.mode {
+            Mode::ChooseProfile { profile_picker, .. } => profile_picker.focus_handle(cx),
+            Mode::ConfigureTools { tool_picker, .. } => tool_picker.focus_handle(cx),
+            Mode::ViewProfile(_) => self.focus_handle.clone(),
+        }
+    }
+}
+
+impl EventEmitter<DismissEvent> for ManageProfilesModal {}
+
+impl ManageProfilesModal {
+    fn render_view_profile(
+        &mut self,
+        mode: ViewProfileMode,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> impl IntoElement {
+        Navigable::new(
+            div()
+                .track_focus(&self.focus_handle(cx))
+                .size_full()
+                .child(
+                    v_flex().child(
+                        div()
+                            .id("configure-tools")
+                            .track_focus(&mode.configure_tools.focus_handle)
+                            .on_action({
+                                let profile_id = mode.profile_id.clone();
+                                cx.listener(move |this, _: &menu::Confirm, window, cx| {
+                                    this.configure_tools(profile_id.clone(), window, cx);
+                                })
+                            })
+                            .child(
+                                ListItem::new("configure-tools")
+                                    .toggle_state(
+                                        mode.configure_tools
+                                            .focus_handle
+                                            .contains_focused(window, cx),
+                                    )
+                                    .inset(true)
+                                    .spacing(ListItemSpacing::Sparse)
+                                    .start_slot(Icon::new(IconName::Cog))
+                                    .child(Label::new("Configure Tools"))
+                                    .on_click({
+                                        let profile_id = mode.profile_id.clone();
+                                        cx.listener(move |this, _, window, cx| {
+                                            this.configure_tools(profile_id.clone(), window, cx);
+                                        })
+                                    }),
+                            ),
+                    ),
+                )
+                .into_any_element(),
+        )
+        .entry(mode.configure_tools)
+    }
+}
+
+impl Render for ManageProfilesModal {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        div()
+            .elevation_3(cx)
+            .w(rems(34.))
+            .key_context("ManageProfilesModal")
+            .on_action(cx.listener(|this, _: &menu::Cancel, window, cx| this.cancel(window, cx)))
+            .on_action(cx.listener(|this, _: &menu::Confirm, window, cx| this.confirm(window, cx)))
+            .capture_any_mouse_down(cx.listener(|this, _, window, cx| {
+                this.focus_handle(cx).focus(window);
+            }))
+            .on_mouse_down_out(cx.listener(|_this, _, _, cx| cx.emit(DismissEvent)))
+            .child(match &self.mode {
+                Mode::ChooseProfile { profile_picker, .. } => {
+                    profile_picker.clone().into_any_element()
+                }
+                Mode::ViewProfile(mode) => self
+                    .render_view_profile(mode.clone(), window, cx)
+                    .into_any_element(),
+                Mode::ConfigureTools { tool_picker, .. } => tool_picker.clone().into_any_element(),
+            })
+    }
+}

crates/assistant2/src/assistant_configuration/profile_picker.rs

@@ -0,0 +1,194 @@
+use std::sync::Arc;
+
+use assistant_settings::AssistantSettings;
+use fuzzy::{match_strings, StringMatch, StringMatchCandidate};
+use gpui::{
+    App, Context, DismissEvent, Entity, EventEmitter, Focusable, SharedString, Task, WeakEntity,
+    Window,
+};
+use picker::{Picker, PickerDelegate};
+use settings::Settings;
+use ui::{prelude::*, HighlightedLabel, ListItem, ListItemSpacing};
+use util::ResultExt as _;
+
+pub struct ProfilePicker {
+    picker: Entity<Picker<ProfilePickerDelegate>>,
+}
+
+impl ProfilePicker {
+    pub fn new(
+        delegate: ProfilePickerDelegate,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let picker = cx.new(|cx| Picker::uniform_list(delegate, window, cx));
+        Self { picker }
+    }
+}
+
+impl EventEmitter<DismissEvent> for ProfilePicker {}
+
+impl Focusable for ProfilePicker {
+    fn focus_handle(&self, cx: &App) -> gpui::FocusHandle {
+        self.picker.focus_handle(cx)
+    }
+}
+
+impl Render for ProfilePicker {
+    fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
+        v_flex().w(rems(34.)).child(self.picker.clone())
+    }
+}
+
+#[derive(Debug)]
+pub struct ProfileEntry {
+    pub id: Arc<str>,
+    pub name: SharedString,
+}
+
+pub struct ProfilePickerDelegate {
+    profile_picker: WeakEntity<ProfilePicker>,
+    profiles: Vec<ProfileEntry>,
+    matches: Vec<StringMatch>,
+    selected_index: usize,
+    on_confirm: Arc<dyn Fn(&Arc<str>, &mut Window, &mut App) + 'static>,
+}
+
+impl ProfilePickerDelegate {
+    pub fn new(
+        on_confirm: impl Fn(&Arc<str>, &mut Window, &mut App) + 'static,
+        cx: &mut Context<ProfilePicker>,
+    ) -> Self {
+        let settings = AssistantSettings::get_global(cx);
+
+        let profiles = settings
+            .profiles
+            .iter()
+            .map(|(id, profile)| ProfileEntry {
+                id: id.clone(),
+                name: profile.name.clone(),
+            })
+            .collect::<Vec<_>>();
+
+        Self {
+            profile_picker: cx.entity().downgrade(),
+            profiles,
+            matches: Vec::new(),
+            selected_index: 0,
+            on_confirm: Arc::new(on_confirm),
+        }
+    }
+}
+
+impl PickerDelegate for ProfilePickerDelegate {
+    type ListItem = ListItem;
+
+    fn match_count(&self) -> usize {
+        self.matches.len()
+    }
+
+    fn selected_index(&self) -> usize {
+        self.selected_index
+    }
+
+    fn set_selected_index(
+        &mut self,
+        ix: usize,
+        _window: &mut Window,
+        _cx: &mut Context<Picker<Self>>,
+    ) {
+        self.selected_index = ix;
+    }
+
+    fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> Arc<str> {
+        "Search profiles…".into()
+    }
+
+    fn update_matches(
+        &mut self,
+        query: String,
+        window: &mut Window,
+        cx: &mut Context<Picker<Self>>,
+    ) -> Task<()> {
+        let background = cx.background_executor().clone();
+        let candidates = self
+            .profiles
+            .iter()
+            .enumerate()
+            .map(|(id, profile)| StringMatchCandidate::new(id, profile.name.as_ref()))
+            .collect::<Vec<_>>();
+
+        cx.spawn_in(window, async move |this, cx| {
+            let matches = if query.is_empty() {
+                candidates
+                    .into_iter()
+                    .enumerate()
+                    .map(|(index, candidate)| StringMatch {
+                        candidate_id: index,
+                        string: candidate.string,
+                        positions: Vec::new(),
+                        score: 0.,
+                    })
+                    .collect()
+            } else {
+                match_strings(
+                    &candidates,
+                    &query,
+                    false,
+                    100,
+                    &Default::default(),
+                    background,
+                )
+                .await
+            };
+
+            this.update(cx, |this, _cx| {
+                this.delegate.matches = matches;
+                this.delegate.selected_index = this
+                    .delegate
+                    .selected_index
+                    .min(this.delegate.matches.len().saturating_sub(1));
+            })
+            .log_err();
+        })
+    }
+
+    fn confirm(&mut self, _secondary: bool, window: &mut Window, cx: &mut Context<Picker<Self>>) {
+        if self.matches.is_empty() {
+            self.dismissed(window, cx);
+            return;
+        }
+
+        let candidate_id = self.matches[self.selected_index].candidate_id;
+        let profile = &self.profiles[candidate_id];
+
+        (self.on_confirm)(&profile.id, window, cx);
+    }
+
+    fn dismissed(&mut self, _window: &mut Window, cx: &mut Context<Picker<Self>>) {
+        self.profile_picker
+            .update(cx, |_this, cx| cx.emit(DismissEvent))
+            .log_err();
+    }
+
+    fn render_match(
+        &self,
+        ix: usize,
+        selected: bool,
+        _window: &mut Window,
+        _cx: &mut Context<Picker<Self>>,
+    ) -> Option<Self::ListItem> {
+        let profile_match = &self.matches[ix];
+
+        Some(
+            ListItem::new(ix)
+                .inset(true)
+                .spacing(ListItemSpacing::Sparse)
+                .toggle_state(selected)
+                .child(HighlightedLabel::new(
+                    profile_match.string.clone(),
+                    profile_match.positions.clone(),
+                )),
+        )
+    }
+}

crates/assistant2/src/assistant_configuration/tool_picker.rs

@@ -1,27 +1,25 @@
 use std::sync::Arc;
 
 use assistant_settings::{
-    AgentProfile, AgentProfileContent, AgentProfileId, AssistantSettings, AssistantSettingsContent,
+    AgentProfile, AgentProfileContent, AssistantSettings, AssistantSettingsContent,
     ContextServerPresetContent, VersionedAssistantSettingsContent,
 };
 use assistant_tool::{ToolSource, ToolWorkingSet};
 use fs::Fs;
-use fuzzy::{StringMatch, StringMatchCandidate, match_strings};
+use fuzzy::{match_strings, StringMatch, StringMatchCandidate};
 use gpui::{App, Context, DismissEvent, Entity, EventEmitter, Focusable, Task, WeakEntity, Window};
 use picker::{Picker, PickerDelegate};
-use settings::{Settings as _, update_settings_file};
-use ui::{HighlightedLabel, ListItem, ListItemSpacing, prelude::*};
+use settings::update_settings_file;
+use ui::{prelude::*, HighlightedLabel, ListItem, ListItemSpacing};
 use util::ResultExt as _;
 
-use crate::ThreadStore;
-
 pub struct ToolPicker {
     picker: Entity<Picker<ToolPickerDelegate>>,
 }
 
 impl ToolPicker {
     pub fn new(delegate: ToolPickerDelegate, window: &mut Window, cx: &mut Context<Self>) -> Self {
-        let picker = cx.new(|cx| Picker::uniform_list(delegate, window, cx).modal(false));
+        let picker = cx.new(|cx| Picker::uniform_list(delegate, window, cx));
         Self { picker }
     }
 }
@@ -48,10 +46,9 @@ pub struct ToolEntry {
 
 pub struct ToolPickerDelegate {
     tool_picker: WeakEntity<ToolPicker>,
-    thread_store: WeakEntity<ThreadStore>,
     fs: Arc<dyn Fs>,
     tools: Vec<ToolEntry>,
-    profile_id: AgentProfileId,
+    profile_id: Arc<str>,
     profile: AgentProfile,
     matches: Vec<StringMatch>,
     selected_index: usize,
@@ -61,8 +58,7 @@ impl ToolPickerDelegate {
     pub fn new(
         fs: Arc<dyn Fs>,
         tool_set: Arc<ToolWorkingSet>,
-        thread_store: WeakEntity<ThreadStore>,
-        profile_id: AgentProfileId,
+        profile_id: Arc<str>,
         profile: AgentProfile,
         cx: &mut Context<ToolPicker>,
     ) -> Self {
@@ -77,7 +73,6 @@ impl ToolPickerDelegate {
 
         Self {
             tool_picker: cx.entity().downgrade(),
-            thread_store,
             fs,
             tools: tool_entries,
             profile_id,
@@ -188,57 +183,45 @@ impl PickerDelegate for ToolPickerDelegate {
             }
         };
 
-        let active_profile_id = &AssistantSettings::get_global(cx).default_profile;
-        if active_profile_id == &self.profile_id {
-            self.thread_store
-                .update(cx, |this, cx| {
-                    this.load_profile(&self.profile, cx);
-                })
-                .log_err();
-        }
-
         update_settings_file::<AssistantSettings>(self.fs.clone(), cx, {
             let profile_id = self.profile_id.clone();
             let default_profile = self.profile.clone();
             let tool = tool.clone();
             move |settings, _cx| match settings {
-                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
+                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,
+                                context_servers: default_profile
                                     .context_servers
-                                    .entry(id.clone().into())
-                                    .or_default();
-                                *preset.tools.entry(tool.name.clone()).or_default() = is_enabled;
-                            }
+                                    .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;
                         }
                     }
                 }

crates/assistant2/src/assistant_model_selector.rs

@@ -7,19 +7,12 @@ use language_model_selector::{
 };
 use settings::update_settings_file;
 use std::sync::Arc;
-use ui::{ButtonLike, PopoverMenuHandle, Tooltip, prelude::*};
-
-#[derive(Clone, Copy)]
-pub enum ModelType {
-    Default,
-    InlineAssistant,
-}
+use ui::{prelude::*, ButtonLike, PopoverMenuHandle, Tooltip};
 
 pub struct AssistantModelSelector {
     selector: Entity<LanguageModelSelector>,
     menu_handle: PopoverMenuHandle<LanguageModelSelector>,
     focus_handle: FocusHandle,
-    model_type: ModelType,
 }
 
 impl AssistantModelSelector {
@@ -27,7 +20,6 @@ impl AssistantModelSelector {
         fs: Arc<dyn Fs>,
         menu_handle: PopoverMenuHandle<LanguageModelSelector>,
         focus_handle: FocusHandle,
-        model_type: ModelType,
         window: &mut Window,
         cx: &mut App,
     ) -> Self {
@@ -36,32 +28,11 @@ impl AssistantModelSelector {
                 let fs = fs.clone();
                 LanguageModelSelector::new(
                     move |model, cx| {
-                        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(),
-                                        );
-                                    },
-                                );
-                            }
-                        }
+                        update_settings_file::<AssistantSettings>(
+                            fs.clone(),
+                            cx,
+                            move |settings, _cx| settings.set_model(model.clone()),
+                        );
                     },
                     window,
                     cx,
@@ -69,7 +40,6 @@ impl AssistantModelSelector {
             }),
             menu_handle,
             focus_handle,
-            model_type,
         }
     }
 
@@ -80,16 +50,10 @@ impl AssistantModelSelector {
 
 impl Render for AssistantModelSelector {
     fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        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 active_model = LanguageModelRegistry::read_global(cx).active_model();
         let focus_handle = self.focus_handle.clone();
-        let model_name = match model {
-            Some(model) => model.model.name().0,
+        let model_name = match active_model {
+            Some(model) => model.name().0,
             _ => SharedString::from("No model selected"),
         };
 

crates/assistant2/src/buffer_codegen.rs

@@ -5,12 +5,12 @@ use anyhow::{Context as _, Result};
 use client::telemetry::Telemetry;
 use collections::HashSet;
 use editor::{Anchor, AnchorRangeExt, MultiBuffer, MultiBufferSnapshot, ToOffset as _, ToPoint};
-use futures::{SinkExt, Stream, StreamExt, channel::mpsc, future::LocalBoxFuture, join};
+use futures::{channel::mpsc, future::LocalBoxFuture, join, SinkExt, Stream, StreamExt};
 use gpui::{App, AppContext as _, Context, Entity, EventEmitter, Subscription, Task};
-use language::{Buffer, IndentKind, Point, TransactionId, line_diff};
+use language::{line_diff, Buffer, IndentKind, Point, TransactionId};
 use language_model::{
-    LanguageModel, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage,
-    LanguageModelTextStream, Role, report_assistant_event,
+    report_assistant_event, LanguageModel, LanguageModelRegistry, LanguageModelRequest,
+    LanguageModelRequestMessage, LanguageModelTextStream, Role,
 };
 use multi_buffer::MultiBufferRow;
 use parking_lot::Mutex;
@@ -156,9 +156,8 @@ impl BufferCodegen {
         }
 
         let primary_model = LanguageModelRegistry::read_global(cx)
-            .default_model()
-            .context("no active model")?
-            .model;
+            .active_model()
+            .context("no active model")?;
 
         for (model, alternative) in iter::once(primary_model)
             .chain(alternative_models)
@@ -415,11 +414,7 @@ impl CodegenAlternative {
         };
 
         if let Some(context_store) = &self.context_store {
-            attach_context_to_message(
-                &mut request_message,
-                context_store.read(cx).context().iter(),
-                cx,
-            );
+            attach_context_to_message(&mut request_message, context_store.read(cx).snapshot(cx));
         }
 
         request_message.content.push(prompt.into());
@@ -1033,14 +1028,14 @@ impl Diff {
 mod tests {
     use super::*;
     use futures::{
-        Stream,
         stream::{self},
+        Stream,
     };
     use gpui::TestAppContext;
     use indoc::indoc;
     use language::{
-        Buffer, Language, LanguageConfig, LanguageMatcher, Point, language_settings,
-        tree_sitter_rust,
+        language_settings, tree_sitter_rust, Buffer, Language, LanguageConfig, LanguageMatcher,
+        Point,
     };
     use language_model::{LanguageModelRegistry, TokenUsage};
     use rand::prelude::*;

crates/assistant2/src/context.rs

@@ -0,0 +1,316 @@
+use std::path::Path;
+use std::rc::Rc;
+
+use file_icons::FileIcons;
+use gpui::{App, Entity, SharedString};
+use language::Buffer;
+use language_model::{LanguageModelRequestMessage, MessageContent};
+use serde::{Deserialize, Serialize};
+use text::BufferId;
+use ui::IconName;
+use util::post_inc;
+
+use crate::{context_store::buffer_path_log_err, thread::Thread};
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, Serialize, Deserialize)]
+pub struct ContextId(pub(crate) usize);
+
+impl ContextId {
+    pub fn post_inc(&mut self) -> Self {
+        Self(post_inc(&mut self.0))
+    }
+}
+
+/// Some context attached to a message in a thread.
+#[derive(Debug, Clone)]
+pub struct ContextSnapshot {
+    pub id: ContextId,
+    pub name: SharedString,
+    pub parent: Option<SharedString>,
+    pub tooltip: Option<SharedString>,
+    pub icon_path: Option<SharedString>,
+    pub kind: ContextKind,
+    /// Joining these strings separated by \n yields text for model. Not refreshed by `snapshot`.
+    pub text: Box<[SharedString]>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ContextKind {
+    File,
+    Directory,
+    FetchedUrl,
+    Thread,
+}
+
+impl ContextKind {
+    pub fn icon(&self) -> IconName {
+        match self {
+            ContextKind::File => IconName::File,
+            ContextKind::Directory => IconName::Folder,
+            ContextKind::FetchedUrl => IconName::Globe,
+            ContextKind::Thread => IconName::MessageCircle,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum AssistantContext {
+    File(FileContext),
+    Directory(DirectoryContext),
+    FetchedUrl(FetchedUrlContext),
+    Thread(ThreadContext),
+}
+
+impl AssistantContext {
+    pub fn id(&self) -> ContextId {
+        match self {
+            Self::File(file) => file.id,
+            Self::Directory(directory) => directory.snapshot.id,
+            Self::FetchedUrl(url) => url.id,
+            Self::Thread(thread) => thread.id,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct FileContext {
+    pub id: ContextId,
+    pub context_buffer: ContextBuffer,
+}
+
+#[derive(Debug)]
+pub struct DirectoryContext {
+    pub path: Rc<Path>,
+    pub context_buffers: Vec<ContextBuffer>,
+    pub snapshot: ContextSnapshot,
+}
+
+#[derive(Debug)]
+pub struct FetchedUrlContext {
+    pub id: ContextId,
+    pub url: SharedString,
+    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)]
+pub struct ThreadContext {
+    pub id: ContextId,
+    pub thread: Entity<Thread>,
+    pub text: SharedString,
+}
+
+// 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(Debug, Clone)]
+pub struct ContextBuffer {
+    pub id: BufferId,
+    pub buffer: Entity<Buffer>,
+    pub version: clock::Global,
+    pub text: SharedString,
+}
+
+impl AssistantContext {
+    pub fn snapshot(&self, cx: &App) -> Option<ContextSnapshot> {
+        match &self {
+            Self::File(file_context) => file_context.snapshot(cx),
+            Self::Directory(directory_context) => Some(directory_context.snapshot()),
+            Self::FetchedUrl(fetched_url_context) => Some(fetched_url_context.snapshot()),
+            Self::Thread(thread_context) => Some(thread_context.snapshot(cx)),
+        }
+    }
+}
+
+impl FileContext {
+    pub fn snapshot(&self, cx: &App) -> Option<ContextSnapshot> {
+        let buffer = self.context_buffer.buffer.read(cx);
+        let path = buffer_path_log_err(buffer)?;
+        let full_path: SharedString = path.to_string_lossy().into_owned().into();
+        let name = match path.file_name() {
+            Some(name) => name.to_string_lossy().into_owned().into(),
+            None => full_path.clone(),
+        };
+        let parent = path
+            .parent()
+            .and_then(|p| p.file_name())
+            .map(|p| p.to_string_lossy().into_owned().into());
+
+        let icon_path = FileIcons::get_icon(&path, cx);
+
+        Some(ContextSnapshot {
+            id: self.id,
+            name,
+            parent,
+            tooltip: Some(full_path),
+            icon_path,
+            kind: ContextKind::File,
+            text: Box::new([self.context_buffer.text.clone()]),
+        })
+    }
+}
+
+impl DirectoryContext {
+    pub fn new(
+        id: ContextId,
+        path: &Path,
+        context_buffers: Vec<ContextBuffer>,
+    ) -> DirectoryContext {
+        let full_path: SharedString = path.to_string_lossy().into_owned().into();
+
+        let name = match path.file_name() {
+            Some(name) => name.to_string_lossy().into_owned().into(),
+            None => full_path.clone(),
+        };
+
+        let parent = path
+            .parent()
+            .and_then(|p| p.file_name())
+            .map(|p| p.to_string_lossy().into_owned().into());
+
+        // TODO: include directory path in text?
+        let text = context_buffers
+            .iter()
+            .map(|b| b.text.clone())
+            .collect::<Vec<_>>()
+            .into();
+
+        DirectoryContext {
+            path: path.into(),
+            context_buffers,
+            snapshot: ContextSnapshot {
+                id,
+                name,
+                parent,
+                tooltip: Some(full_path),
+                icon_path: None,
+                kind: ContextKind::Directory,
+                text,
+            },
+        }
+    }
+
+    pub fn snapshot(&self) -> ContextSnapshot {
+        self.snapshot.clone()
+    }
+}
+
+impl FetchedUrlContext {
+    pub fn snapshot(&self) -> ContextSnapshot {
+        ContextSnapshot {
+            id: self.id,
+            name: self.url.clone(),
+            parent: None,
+            tooltip: None,
+            icon_path: None,
+            kind: ContextKind::FetchedUrl,
+            text: Box::new([self.text.clone()]),
+        }
+    }
+}
+
+impl ThreadContext {
+    pub fn snapshot(&self, cx: &App) -> ContextSnapshot {
+        let thread = self.thread.read(cx);
+        ContextSnapshot {
+            id: self.id,
+            name: thread.summary().unwrap_or("New thread".into()),
+            parent: None,
+            tooltip: None,
+            icon_path: None,
+            kind: ContextKind::Thread,
+            text: Box::new([self.text.clone()]),
+        }
+    }
+}
+
+pub fn attach_context_to_message(
+    message: &mut LanguageModelRequestMessage,
+    contexts: impl Iterator<Item = ContextSnapshot>,
+) {
+    let mut file_context = Vec::new();
+    let mut directory_context = Vec::new();
+    let mut fetch_context = Vec::new();
+    let mut thread_context = Vec::new();
+
+    let mut capacity = 0;
+    for context in contexts {
+        capacity += context.text.len();
+        match context.kind {
+            ContextKind::File => file_context.push(context),
+            ContextKind::Directory => directory_context.push(context),
+            ContextKind::FetchedUrl => fetch_context.push(context),
+            ContextKind::Thread => thread_context.push(context),
+        }
+    }
+    if !file_context.is_empty() {
+        capacity += 1;
+    }
+    if !directory_context.is_empty() {
+        capacity += 1;
+    }
+    if !fetch_context.is_empty() {
+        capacity += 1 + fetch_context.len();
+    }
+    if !thread_context.is_empty() {
+        capacity += 1 + thread_context.len();
+    }
+    if capacity == 0 {
+        return;
+    }
+
+    let mut context_chunks = Vec::with_capacity(capacity);
+
+    if !file_context.is_empty() {
+        context_chunks.push("The following files are available:\n");
+        for context in &file_context {
+            for chunk in &context.text {
+                context_chunks.push(&chunk);
+            }
+        }
+    }
+
+    if !directory_context.is_empty() {
+        context_chunks.push("The following directories are available:\n");
+        for context in &directory_context {
+            for chunk in &context.text {
+                context_chunks.push(&chunk);
+            }
+        }
+    }
+
+    if !fetch_context.is_empty() {
+        context_chunks.push("The following fetched results are available:\n");
+        for context in &fetch_context {
+            context_chunks.push(&context.name);
+            for chunk in &context.text {
+                context_chunks.push(&chunk);
+            }
+        }
+    }
+
+    if !thread_context.is_empty() {
+        context_chunks.push("The following previous conversation threads are available:\n");
+        for context in &thread_context {
+            context_chunks.push(&context.name);
+            for chunk in &context.text {
+                context_chunks.push(&chunk);
+            }
+        }
+    }
+
+    debug_assert!(
+        context_chunks.len() == capacity,
+        "attach_context_message calculated capacity of {}, but length was {}",
+        capacity,
+        context_chunks.len()
+    );
+
+    if !context_chunks.is_empty() {
+        message
+            .content
+            .push(MessageContent::Text(context_chunks.join("\n")));
+    }
+}

crates/assistant2/src/context_picker.rs

@@ -1,14 +1,13 @@
 mod completion_provider;
 mod fetch_context_picker;
 mod file_context_picker;
-mod symbol_context_picker;
 mod thread_context_picker;
 
 use std::ops::Range;
 use std::path::PathBuf;
 use std::sync::Arc;
 
-use anyhow::{Result, anyhow};
+use anyhow::{anyhow, Result};
 use editor::display_map::{Crease, FoldId};
 use editor::{Anchor, AnchorRangeExt as _, Editor, ExcerptId, FoldPlaceholder, ToOffset};
 use file_context_picker::render_file_context_entry;
@@ -16,22 +15,20 @@ use gpui::{
     App, DismissEvent, Empty, Entity, EventEmitter, FocusHandle, Focusable, Task, WeakEntity,
 };
 use multi_buffer::MultiBufferRow;
-use project::{Entry, ProjectPath};
-use symbol_context_picker::SymbolContextPicker;
-use thread_context_picker::{ThreadContextEntry, render_thread_context_entry};
+use project::ProjectPath;
+use thread_context_picker::{render_thread_context_entry, ThreadContextEntry};
 use ui::{
-    ButtonLike, ContextMenu, ContextMenuEntry, ContextMenuItem, Disclosure, TintColor, prelude::*,
+    prelude::*, ButtonLike, ContextMenu, ContextMenuEntry, ContextMenuItem, Disclosure, TintColor,
 };
-use workspace::{Workspace, notifications::NotifyResultExt};
+use workspace::{notifications::NotifyResultExt, Workspace};
 
-use crate::AssistantPanel;
 pub use crate::context_picker::completion_provider::ContextPickerCompletionProvider;
 use crate::context_picker::fetch_context_picker::FetchContextPicker;
 use crate::context_picker::file_context_picker::FileContextPicker;
 use crate::context_picker::thread_context_picker::ThreadContextPicker;
 use crate::context_store::ContextStore;
-use crate::thread::ThreadId;
 use crate::thread_store::ThreadStore;
+use crate::AssistantPanel;
 
 #[derive(Debug, Clone, Copy)]
 pub enum ConfirmBehavior {
@@ -42,7 +39,6 @@ pub enum ConfirmBehavior {
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum ContextPickerMode {
     File,
-    Symbol,
     Fetch,
     Thread,
 }
@@ -53,7 +49,6 @@ impl TryFrom<&str> for ContextPickerMode {
     fn try_from(value: &str) -> Result<Self, Self::Error> {
         match value {
             "file" => Ok(Self::File),
-            "symbol" => Ok(Self::Symbol),
             "fetch" => Ok(Self::Fetch),
             "thread" => Ok(Self::Thread),
             _ => Err(format!("Invalid context picker mode: {}", value)),
@@ -65,7 +60,6 @@ impl ContextPickerMode {
     pub fn mention_prefix(&self) -> &'static str {
         match self {
             Self::File => "file",
-            Self::Symbol => "symbol",
             Self::Fetch => "fetch",
             Self::Thread => "thread",
         }
@@ -74,18 +68,16 @@ impl ContextPickerMode {
     pub fn label(&self) -> &'static str {
         match self {
             Self::File => "Files & Directories",
-            Self::Symbol => "Symbols",
             Self::Fetch => "Fetch",
-            Self::Thread => "Threads",
+            Self::Thread => "Thread",
         }
     }
 
     pub fn icon(&self) -> IconName {
         match self {
             Self::File => IconName::File,
-            Self::Symbol => IconName::Code,
             Self::Fetch => IconName::Globe,
-            Self::Thread => IconName::MessageBubbles,
+            Self::Thread => IconName::MessageCircle,
         }
     }
 }
@@ -94,7 +86,6 @@ impl ContextPickerMode {
 enum ContextPickerState {
     Default(Entity<ContextMenu>),
     File(Entity<FileContextPicker>),
-    Symbol(Entity<SymbolContextPicker>),
     Fetch(Entity<FetchContextPicker>),
     Thread(Entity<ThreadContextPicker>),
 }
@@ -214,18 +205,6 @@ impl ContextPicker {
                     )
                 }));
             }
-            ContextPickerMode::Symbol => {
-                self.mode = ContextPickerState::Symbol(cx.new(|cx| {
-                    SymbolContextPicker::new(
-                        context_picker.clone(),
-                        self.workspace.clone(),
-                        self.context_store.clone(),
-                        self.confirm_behavior,
-                        window,
-                        cx,
-                    )
-                }));
-            }
             ContextPickerMode::Fetch => {
                 self.mode = ContextPickerState::Fetch(cx.new(|cx| {
                     FetchContextPicker::new(
@@ -360,15 +339,73 @@ impl ContextPicker {
     }
 
     fn recent_entries(&self, cx: &mut App) -> Vec<RecentEntry> {
-        let Some(workspace) = self.workspace.upgrade() else {
+        let Some(workspace) = self.workspace.upgrade().map(|w| w.read(cx)) else {
             return vec![];
         };
 
-        let Some(context_store) = self.context_store.upgrade() else {
+        let Some(context_store) = self.context_store.upgrade().map(|cs| cs.read(cx)) else {
             return vec![];
         };
 
-        recent_context_picker_entries(context_store, self.thread_store.clone(), workspace, cx)
+        let mut recent = Vec::with_capacity(6);
+
+        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);
+        }
+
+        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
     }
 }
 
@@ -379,7 +416,6 @@ impl Focusable for ContextPicker {
         match &self.mode {
             ContextPickerState::Default(menu) => menu.focus_handle(cx),
             ContextPickerState::File(file_picker) => file_picker.focus_handle(cx),
-            ContextPickerState::Symbol(symbol_picker) => symbol_picker.focus_handle(cx),
             ContextPickerState::Fetch(fetch_picker) => fetch_picker.focus_handle(cx),
             ContextPickerState::Thread(thread_picker) => thread_picker.focus_handle(cx),
         }
@@ -394,7 +430,6 @@ impl Render for ContextPicker {
             .map(|parent| match &self.mode {
                 ContextPickerState::Default(menu) => parent.child(menu.clone()),
                 ContextPickerState::File(file_picker) => parent.child(file_picker.clone()),
-                ContextPickerState::Symbol(symbol_picker) => parent.child(symbol_picker.clone()),
                 ContextPickerState::Fetch(fetch_picker) => parent.child(fetch_picker.clone()),
                 ContextPickerState::Thread(thread_picker) => parent.child(thread_picker.clone()),
             })
@@ -411,17 +446,23 @@ enum RecentEntry {
 fn supported_context_picker_modes(
     thread_store: &Option<WeakEntity<ThreadStore>>,
 ) -> Vec<ContextPickerMode> {
-    let mut modes = vec![
-        ContextPickerMode::File,
-        ContextPickerMode::Symbol,
-        ContextPickerMode::Fetch,
-    ];
+    let mut modes = vec![ContextPickerMode::File, ContextPickerMode::Fetch];
     if thread_store.is_some() {
         modes.push(ContextPickerMode::Thread);
     }
     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>>,
@@ -430,8 +471,14 @@ fn recent_context_picker_entries(
 ) -> Vec<RecentEntry> {
     let mut recent = Vec::with_capacity(6);
 
-    let current_files = context_store.read(cx).file_paths(cx);
+    let mut 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(
@@ -495,7 +542,6 @@ pub(crate) fn insert_crease_for_mention(
             return;
         };
 
-        let start = start.bias_right(&snapshot);
         let end = snapshot.anchor_before(start.to_offset(&snapshot) + content_len);
 
         let placeholder = FoldPlaceholder {
@@ -605,93 +651,3 @@ fn fold_toggle(
             .into_any_element()
     }
 }
-
-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_name, Self::FILE, full_path)
-    }
-
-    pub fn for_symbol(symbol_name: &str, full_path: &str) -> String {
-        format!(
-            "[@{}]({}:{}:{})",
-            symbol_name,
-            Self::SYMBOL,
-            full_path,
-            symbol_name
-        )
-    }
-
-    pub fn for_fetch(url: &str) -> String {
-        format!("[@{}]({}:{})", url, Self::FETCH, url)
-    }
-
-    pub fn for_thread(thread: &ThreadContextEntry) -> String {
-        format!("[@{}]({}:{})", thread.summary, Self::THREAD, thread.id)
-    }
-
-    pub fn try_parse(link: &str, workspace: &Entity<Workspace>, cx: &App) -> Option<Self> {
-        fn extract_project_path_from_link(
-            path: &str,
-            workspace: &Entity<Workspace>,
-            cx: &App,
-        ) -> Option<ProjectPath> {
-            let path = PathBuf::from(path);
-            let worktree_name = path.iter().next()?;
-            let path: PathBuf = path.iter().skip(1).collect();
-            let worktree_id = workspace
-                .read(cx)
-                .visible_worktrees(cx)
-                .find(|worktree| worktree.read(cx).root_name() == worktree_name)
-                .map(|worktree| worktree.read(cx).id())?;
-            Some(ProjectPath {
-                worktree_id,
-                path: path.into(),
-            })
-        }
-
-        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()
-                    .read(cx)
-                    .entry_for_path(&project_path, cx)?;
-                Some(MentionLink::File(project_path, entry))
-            }
-            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.to_string()))
-            }
-            Self::THREAD => {
-                let thread_id = ThreadId::from(argument);
-                Some(MentionLink::Thread(thread_id))
-            }
-            Self::FETCH => Some(MentionLink::Fetch(argument.to_string())),
-            _ => None,
-        }
-    }
-}

crates/assistant2/src/context_picker/completion_provider.rs

@@ -1,9 +1,9 @@
 use std::cell::RefCell;
 use std::ops::Range;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::rc::Rc;
-use std::sync::Arc;
 use std::sync::atomic::AtomicBool;
+use std::sync::Arc;
 
 use anyhow::Result;
 use editor::{CompletionProvider, Editor, ExcerptId};
@@ -12,7 +12,7 @@ use gpui::{App, Entity, Task, WeakEntity};
 use http_client::HttpClientWithUrl;
 use language::{Buffer, CodeLabel, HighlightId};
 use lsp::CompletionContext;
-use project::{Completion, CompletionIntent, ProjectPath, Symbol, WorktreeId};
+use project::{Completion, CompletionIntent, ProjectPath, WorktreeId};
 use rope::Point;
 use text::{Anchor, ToPoint};
 use ui::prelude::*;
@@ -24,9 +24,7 @@ use crate::thread_store::ThreadStore;
 
 use super::fetch_context_picker::fetch_url_content;
 use super::thread_context_picker::ThreadContextEntry;
-use super::{
-    ContextPickerMode, MentionLink, recent_context_picker_entries, supported_context_picker_modes,
-};
+use super::{recent_context_picker_entries, supported_context_picker_modes, ContextPickerMode};
 
 pub struct ContextPickerCompletionProvider {
     workspace: WeakEntity<Workspace>,
@@ -72,18 +70,18 @@ impl ContextPickerCompletionProvider {
             .filter_map(|entry| match entry {
                 super::RecentEntry::File {
                     project_path,
-                    path_prefix,
-                } => Some(Self::completion_for_path(
+                    path_prefix: _,
+                } => Self::completion_for_path(
                     project_path.clone(),
-                    path_prefix,
                     true,
                     false,
                     excerpt_id,
                     source_range.clone(),
                     editor.clone(),
                     context_store.clone(),
+                    workspace.clone(),
                     cx,
-                )),
+                ),
                 super::RecentEntry::Thread(thread_context_entry) => {
                     let thread_store = thread_store
                         .as_ref()
@@ -122,24 +120,56 @@ impl ContextPickerCompletionProvider {
         completions
     }
 
-    fn build_code_label_for_full_path(
-        file_name: &str,
-        directory: Option<&str>,
+    fn full_path_for_entry(
+        worktree_id: WorktreeId,
+        path: &Path,
+        workspace: Entity<Workspace>,
         cx: &App,
-    ) -> CodeLabel {
+    ) -> Option<PathBuf> {
+        let worktree = workspace
+            .read(cx)
+            .project()
+            .read(cx)
+            .worktree_for_id(worktree_id, cx)?
+            .read(cx);
+
+        let mut full_path = PathBuf::from(worktree.root_name());
+        full_path.push(path);
+        Some(full_path)
+    }
+
+    fn build_code_label_for_full_path(
+        worktree_id: WorktreeId,
+        path: &Path,
+        workspace: Entity<Workspace>,
+        cx: &App,
+    ) -> Option<CodeLabel> {
         let comment_id = cx.theme().syntax().highlight_id("comment").map(HighlightId);
         let mut label = CodeLabel::default();
+        let worktree = workspace
+            .read(cx)
+            .project()
+            .read(cx)
+            .worktree_for_id(worktree_id, cx)?;
 
+        let entry = worktree.read(cx).entry_for_path(&path)?;
+        let file_name = path.file_name()?.to_string_lossy();
         label.push_str(&file_name, None);
-        label.push_str(" ", None);
+        if entry.is_dir() {
+            label.push_str("/ ", None);
+        } else {
+            label.push_str(" ", None);
+        };
 
-        if let Some(directory) = directory {
-            label.push_str(&directory, comment_id);
+        let mut path_hint = PathBuf::from(worktree.read(cx).root_name());
+        if let Some(path_to_entry) = path.parent() {
+            path_hint.push(path_to_entry);
         }
+        label.push_str(&path_hint.to_string_lossy(), comment_id);
 
         label.filter_range = 0..label.text().len();
 
-        label
+        Some(label)
     }
 
     fn completion_for_thread(
@@ -154,9 +184,9 @@ impl ContextPickerCompletionProvider {
         let icon_for_completion = if recent {
             IconName::HistoryRerun
         } else {
-            IconName::MessageBubbles
+            IconName::MessageCircle
         };
-        let new_text = MentionLink::for_thread(&thread_entry);
+        let new_text = format!("@thread {}", thread_entry.summary);
         let new_text_len = new_text.len();
         Completion {
             old_range: source_range.clone(),
@@ -166,7 +196,7 @@ impl ContextPickerCompletionProvider {
             source: project::CompletionSource::Custom,
             icon_path: Some(icon_for_completion.path().into()),
             confirm: Some(confirm_completion_callback(
-                IconName::MessageBubbles.path().into(),
+                IconName::MessageCircle.path().into(),
                 thread_entry.summary.clone(),
                 excerpt_id,
                 source_range.start,
@@ -200,7 +230,7 @@ impl ContextPickerCompletionProvider {
         context_store: Entity<ContextStore>,
         http_client: Arc<HttpClientWithUrl>,
     ) -> Completion {
-        let new_text = MentionLink::for_fetch(&url_to_fetch);
+        let new_text = format!("@fetch {}", url_to_fetch);
         let new_text_len = new_text.len();
         Completion {
             old_range: source_range.clone(),
@@ -244,36 +274,32 @@ impl ContextPickerCompletionProvider {
 
     fn completion_for_path(
         project_path: ProjectPath,
-        path_prefix: &str,
         is_recent: bool,
         is_directory: bool,
         excerpt_id: ExcerptId,
         source_range: Range<Anchor>,
         editor: Entity<Editor>,
         context_store: Entity<ContextStore>,
+        workspace: Entity<Workspace>,
         cx: &App,
-    ) -> Completion {
-        let (file_name, directory) = super::file_context_picker::extract_file_name_and_directory(
-            &project_path.path,
-            path_prefix,
-        );
-
+    ) -> Option<Completion> {
         let label = Self::build_code_label_for_full_path(
-            &file_name,
-            directory.as_ref().map(|s| s.as_ref()),
+            project_path.worktree_id,
+            &project_path.path,
+            workspace.clone(),
             cx,
-        );
-        let full_path = if let Some(directory) = directory {
-            format!("{}{}", directory, file_name)
-        } else {
-            file_name.to_string()
-        };
+        )?;
+        let full_path = Self::full_path_for_entry(
+            project_path.worktree_id,
+            &project_path.path,
+            workspace.clone(),
+            cx,
+        )?;
 
         let crease_icon_path = if is_directory {
             FileIcons::get_folder_icon(false, cx).unwrap_or_else(|| IconName::Folder.path().into())
         } else {
-            FileIcons::get_icon(Path::new(&full_path), cx)
-                .unwrap_or_else(|| IconName::File.path().into())
+            FileIcons::get_icon(&full_path, cx).unwrap_or_else(|| IconName::File.path().into())
         };
         let completion_icon_path = if is_recent {
             IconName::HistoryRerun.path().into()
@@ -281,9 +307,15 @@ impl ContextPickerCompletionProvider {
             crease_icon_path.clone()
         };
 
-        let new_text = MentionLink::for_file(&file_name, &full_path);
+        let crease_name = project_path
+            .path
+            .file_name()
+            .map(|file_name| file_name.to_string_lossy().to_string())
+            .unwrap_or_else(|| "untitled".to_string());
+
+        let new_text = format!("@file {}", full_path.to_string_lossy());
         let new_text_len = new_text.len();
-        Completion {
+        Some(Completion {
             old_range: source_range.clone(),
             new_text,
             label,
@@ -292,7 +324,7 @@ impl ContextPickerCompletionProvider {
             icon_path: Some(completion_icon_path),
             confirm: Some(confirm_completion_callback(
                 crease_icon_path,
-                file_name,
+                crease_name.into(),
                 excerpt_id,
                 source_range.start,
                 new_text_len,
@@ -308,71 +340,6 @@ impl ContextPickerCompletionProvider {
                     })
                 },
             )),
-        }
-    }
-
-    fn completion_for_symbol(
-        symbol: Symbol,
-        excerpt_id: ExcerptId,
-        source_range: Range<Anchor>,
-        editor: Entity<Editor>,
-        context_store: Entity<ContextStore>,
-        workspace: Entity<Workspace>,
-        cx: &mut App,
-    ) -> Option<Completion> {
-        let path_prefix = workspace
-            .read(cx)
-            .project()
-            .read(cx)
-            .worktree_for_id(symbol.path.worktree_id, cx)?
-            .read(cx)
-            .root_name();
-
-        let (file_name, directory) = super::file_context_picker::extract_file_name_and_directory(
-            &symbol.path.path,
-            path_prefix,
-        );
-        let full_path = if let Some(directory) = directory {
-            format!("{}{}", directory, file_name)
-        } else {
-            file_name.to_string()
-        };
-
-        let comment_id = cx.theme().syntax().highlight_id("comment").map(HighlightId);
-        let mut label = CodeLabel::plain(symbol.name.clone(), None);
-        label.push_str(" ", None);
-        label.push_str(&file_name, comment_id);
-
-        let new_text = MentionLink::for_symbol(&symbol.name, &full_path);
-        let new_text_len = new_text.len();
-        Some(Completion {
-            old_range: source_range.clone(),
-            new_text,
-            label,
-            documentation: None,
-            source: project::CompletionSource::Custom,
-            icon_path: Some(IconName::Code.path().into()),
-            confirm: Some(confirm_completion_callback(
-                IconName::Code.path().into(),
-                symbol.name.clone().into(),
-                excerpt_id,
-                source_range.start,
-                new_text_len,
-                editor.clone(),
-                move |cx| {
-                    let symbol = symbol.clone();
-                    let context_store = context_store.clone();
-                    let workspace = workspace.clone();
-                    super::symbol_context_picker::add_symbol(
-                        symbol.clone(),
-                        false,
-                        workspace.clone(),
-                        context_store.downgrade(),
-                        cx,
-                    )
-                    .detach_and_log_err(cx);
-                },
-            )),
         })
     }
 }
@@ -407,7 +374,7 @@ impl CompletionProvider for ContextPickerCompletionProvider {
         };
 
         let snapshot = buffer.read(cx).snapshot();
-        let source_range = snapshot.anchor_before(state.source_range.start)
+        let source_range = snapshot.anchor_after(state.source_range.start)
             ..snapshot.anchor_before(state.source_range.end);
 
         let thread_store = self.thread_store.clone();
@@ -417,72 +384,46 @@ impl CompletionProvider for ContextPickerCompletionProvider {
         cx.spawn(async move |_, cx| {
             let mut completions = Vec::new();
 
-            let MentionCompletion { mode, argument, .. } = state;
+            let MentionCompletion {
+                mode: category,
+                argument,
+                ..
+            } = state;
 
             let query = argument.unwrap_or_else(|| "".to_string());
-            match mode {
+            match category {
                 Some(ContextPickerMode::File) => {
                     let path_matches = cx
                         .update(|cx| {
                             super::file_context_picker::search_paths(
                                 query,
-                                Arc::<AtomicBool>::default(),
+                                Arc::new(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,
-                                    )
+                    completions.reserve(path_matches.len());
+                    cx.update(|cx| {
+                        completions.extend(path_matches.iter().filter_map(|mat| {
+                            let editor = editor.upgrade()?;
+                            Self::completion_for_path(
+                                ProjectPath {
+                                    worktree_id: WorktreeId::from_usize(mat.worktree_id),
+                                    path: mat.path.clone(),
                                 },
-                            ));
-                        })?;
-                    }
+                                false,
+                                mat.is_dir,
+                                excerpt_id,
+                                source_range.clone(),
+                                editor.clone(),
+                                context_store.clone(),
+                                workspace.clone(),
+                                cx,
+                            )
+                        }));
+                    })?;
                 }
                 Some(ContextPickerMode::Fetch) => {
                     if let Some(editor) = editor.upgrade() {
@@ -653,15 +594,6 @@ impl MentionCompletion {
         if last_mention_start >= line.len() {
             return Some(Self::default());
         }
-        if last_mention_start > 0
-            && line
-                .chars()
-                .nth(last_mention_start - 1)
-                .map_or(false, |c| !c.is_whitespace())
-        {
-            return None;
-        }
-
         let rest_of_line = &line[last_mention_start + 1..];
 
         let mut mode = None;
@@ -762,8 +694,6 @@ mod tests {
                 argument: Some("main.rs".to_string()),
             })
         );
-
-        assert_eq!(MentionCompletion::try_parse("test@", 0), None);
     }
 
     #[gpui::test]
@@ -841,6 +771,7 @@ mod tests {
                 .unwrap();
         }
 
+        //TODO: Construct the editor without an actual buffer that points to a file
         let item = workspace
             .update_in(&mut cx, |workspace, window, cx| {
                 workspace.open_path(
@@ -862,7 +793,7 @@ mod tests {
                 .expect("Opened test file wasn't an editor")
         });
 
-        let context_store = cx.new(|_| ContextStore::new(workspace.downgrade(), None));
+        let context_store = cx.new(|_| ContextStore::new(workspace.downgrade()));
 
         let editor_entity = editor.downgrade();
         editor.update_in(&mut cx, |editor, window, cx| {
@@ -890,12 +821,11 @@ mod tests {
             assert_eq!(
                 current_completion_labels(editor),
                 &[
-                    "editor dir/",
-                    "seven.txt dir/b/",
-                    "six.txt dir/b/",
-                    "five.txt dir/b/",
+                    format!("seven.txt {}", separator!("dir/b")).as_str(),
+                    format!("six.txt {}", separator!("dir/b")).as_str(),
+                    format!("five.txt {}", separator!("dir/b")).as_str(),
+                    format!("four.txt {}", separator!("dir/a")).as_str(),
                     "Files & Directories",
-                    "Symbols",
                     "Fetch"
                 ]
             );
@@ -923,7 +853,10 @@ mod tests {
         editor.update(&mut cx, |editor, cx| {
             assert_eq!(editor.text(cx), "Lorem @file one");
             assert!(editor.has_visible_completions_menu());
-            assert_eq!(current_completion_labels(editor), vec!["one.txt dir/a/"]);
+            assert_eq!(
+                current_completion_labels(editor),
+                vec![format!("one.txt {}", separator!("dir/a")).as_str(),]
+            );
         });
 
         editor.update_in(&mut cx, |editor, window, cx| {
@@ -932,22 +865,28 @@ 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),
+                format!("Lorem @file {}", separator!("dir/a/one.txt"))
+            );
             assert!(!editor.has_visible_completions_menu());
             assert_eq!(
                 crease_ranges(editor, cx),
-                vec![Point::new(0, 6)..Point::new(0, 37)]
+                vec![Point::new(0, 6)..Point::new(0, 25)]
             );
         });
 
         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),
+                format!("Lorem @file {} ", separator!("dir/a/one.txt"))
+            );
             assert!(!editor.has_visible_completions_menu());
             assert_eq!(
                 crease_ranges(editor, cx),
-                vec![Point::new(0, 6)..Point::new(0, 37)]
+                vec![Point::new(0, 6)..Point::new(0, 25)]
             );
         });
 
@@ -956,12 +895,12 @@ mod tests {
         editor.update(&mut cx, |editor, cx| {
             assert_eq!(
                 editor.text(cx),
-                "Lorem [@one.txt](@file:dir/a/one.txt) Ipsum ",
+                format!("Lorem @file {} Ipsum ", separator!("dir/a/one.txt"))
             );
             assert!(!editor.has_visible_completions_menu());
             assert_eq!(
                 crease_ranges(editor, cx),
-                vec![Point::new(0, 6)..Point::new(0, 37)]
+                vec![Point::new(0, 6)..Point::new(0, 25)]
             );
         });
 
@@ -970,12 +909,12 @@ mod tests {
         editor.update(&mut cx, |editor, cx| {
             assert_eq!(
                 editor.text(cx),
-                "Lorem [@one.txt](@file:dir/a/one.txt) Ipsum @file ",
+                format!("Lorem @file {} Ipsum @file ", separator!("dir/a/one.txt"))
             );
             assert!(editor.has_visible_completions_menu());
             assert_eq!(
                 crease_ranges(editor, cx),
-                vec![Point::new(0, 6)..Point::new(0, 37)]
+                vec![Point::new(0, 6)..Point::new(0, 25)]
             );
         });
 
@@ -988,14 +927,18 @@ mod tests {
         editor.update(&mut cx, |editor, cx| {
             assert_eq!(
                 editor.text(cx),
-                "Lorem [@one.txt](@file:dir/a/one.txt) Ipsum [@editor](@file:dir/editor)"
+                format!(
+                    "Lorem @file {} Ipsum @file {}",
+                    separator!("dir/a/one.txt"),
+                    separator!("dir/b/seven.txt")
+                )
             );
             assert!(!editor.has_visible_completions_menu());
             assert_eq!(
                 crease_ranges(editor, cx),
                 vec![
-                    Point::new(0, 6)..Point::new(0, 37),
-                    Point::new(0, 44)..Point::new(0, 71)
+                    Point::new(0, 6)..Point::new(0, 25),
+                    Point::new(0, 32)..Point::new(0, 53)
                 ]
             );
         });
@@ -1005,14 +948,18 @@ mod tests {
         editor.update(&mut cx, |editor, cx| {
             assert_eq!(
                 editor.text(cx),
-                "Lorem [@one.txt](@file:dir/a/one.txt) Ipsum [@editor](@file:dir/editor)\n@"
+                format!(
+                    "Lorem @file {} Ipsum @file {}\n@",
+                    separator!("dir/a/one.txt"),
+                    separator!("dir/b/seven.txt")
+                )
             );
             assert!(editor.has_visible_completions_menu());
             assert_eq!(
                 crease_ranges(editor, cx),
                 vec![
-                    Point::new(0, 6)..Point::new(0, 37),
-                    Point::new(0, 44)..Point::new(0, 71)
+                    Point::new(0, 6)..Point::new(0, 25),
+                    Point::new(0, 32)..Point::new(0, 53)
                 ]
             );
         });
@@ -1026,15 +973,20 @@ mod tests {
         editor.update(&mut cx, |editor, cx| {
             assert_eq!(
                 editor.text(cx),
-                "Lorem [@one.txt](@file:dir/a/one.txt) Ipsum [@editor](@file:dir/editor)\n[@seven.txt](@file:dir/b/seven.txt)"
+                format!(
+                    "Lorem @file {} Ipsum @file {}\n@file {}",
+                    separator!("dir/a/one.txt"),
+                    separator!("dir/b/seven.txt"),
+                    separator!("dir/b/six.txt"),
+                )
             );
             assert!(!editor.has_visible_completions_menu());
             assert_eq!(
                 crease_ranges(editor, cx),
                 vec![
-                    Point::new(0, 6)..Point::new(0, 37),
-                    Point::new(0, 44)..Point::new(0, 71),
-                    Point::new(1, 0)..Point::new(1, 35)
+                    Point::new(0, 6)..Point::new(0, 25),
+                    Point::new(0, 32)..Point::new(0, 53),
+                    Point::new(1, 0)..Point::new(1, 19)
                 ]
             );
         });

crates/assistant2/src/context_picker/fetch_context_picker.rs

@@ -2,13 +2,13 @@ use std::cell::RefCell;
 use std::rc::Rc;
 use std::sync::Arc;
 
-use anyhow::{Context as _, Result, bail};
+use anyhow::{bail, Context as _, Result};
 use futures::AsyncReadExt as _;
 use gpui::{App, DismissEvent, Entity, FocusHandle, Focusable, Task, WeakEntity};
-use html_to_markdown::{TagHandler, convert_html_to_markdown, markdown};
+use html_to_markdown::{convert_html_to_markdown, markdown, TagHandler};
 use http_client::{AsyncBody, HttpClientWithUrl};
 use picker::{Picker, PickerDelegate};
-use ui::{Context, ListItem, Window, prelude::*};
+use ui::{prelude::*, Context, ListItem, Window};
 use workspace::Workspace;
 
 use crate::context_picker::{ConfirmBehavior, ContextPicker};
@@ -163,7 +163,11 @@ impl PickerDelegate for FetchContextPickerDelegate {
     type ListItem = ListItem;
 
     fn match_count(&self) -> usize {
-        if self.url.is_empty() { 0 } else { 1 }
+        if self.url.is_empty() {
+            0
+        } else {
+            1
+        }
     }
 
     fn no_matches_text(&self, _window: &mut Window, _cx: &mut App) -> Option<SharedString> {

crates/assistant2/src/context_picker/file_context_picker.rs

@@ -1,6 +1,6 @@
 use std::path::Path;
-use std::sync::Arc;
 use std::sync::atomic::AtomicBool;
+use std::sync::Arc;
 
 use file_icons::FileIcons;
 use fuzzy::PathMatch;
@@ -9,9 +9,9 @@ use gpui::{
 };
 use picker::{Picker, PickerDelegate};
 use project::{PathMatchCandidateSet, ProjectPath, WorktreeId};
-use ui::{ListItem, Tooltip, prelude::*};
+use ui::{prelude::*, ListItem, Tooltip};
 use util::ResultExt as _;
-use workspace::{Workspace, notifications::NotifyResultExt};
+use workspace::{notifications::NotifyResultExt, Workspace};
 
 use crate::context_picker::{ConfirmBehavior, ContextPicker};
 use crate::context_store::{ContextStore, FileInclusion};
@@ -273,17 +273,17 @@ pub(crate) fn search_paths(
     }
 }
 
-pub fn extract_file_name_and_directory(
+pub fn render_file_context_entry(
+    id: ElementId,
     path: &Path,
-    path_prefix: &str,
-) -> (SharedString, Option<SharedString>) {
-    if path == Path::new("") {
+    path_prefix: &Arc<str>,
+    is_directory: bool,
+    context_store: WeakEntity<ContextStore>,
+    cx: &App,
+) -> Stateful<Div> {
+    let (file_name, directory) = if path == Path::new("") {
         (
-            SharedString::from(
-                path_prefix
-                    .trim_end_matches(std::path::MAIN_SEPARATOR)
-                    .to_string(),
-            ),
+            SharedString::from(path_prefix.trim_end_matches('/').to_string()),
             None,
         )
     } else {
@@ -294,9 +294,7 @@ pub fn extract_file_name_and_directory(
             .to_string()
             .into();
 
-        let mut directory = path_prefix
-            .trim_end_matches(std::path::MAIN_SEPARATOR)
-            .to_string();
+        let mut directory = path_prefix.to_string();
         if !directory.ends_with('/') {
             directory.push('/');
         }
@@ -305,23 +303,15 @@ pub fn extract_file_name_and_directory(
             directory.push('/');
         }
 
-        (file_name, Some(directory.into()))
-    }
-}
-
-pub fn render_file_context_entry(
-    id: ElementId,
-    path: &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);
+        (file_name, Some(directory))
+    };
 
     let added = context_store.upgrade().and_then(|context_store| {
         if is_directory {
-            context_store.read(cx).includes_directory(path)
+            context_store
+                .read(cx)
+                .includes_directory(path)
+                .map(FileInclusion::Direct)
         } else {
             context_store.read(cx).will_include_file_path(path, cx)
         }

crates/assistant2/src/context_picker/thread_context_picker.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use fuzzy::StringMatchCandidate;
 use gpui::{App, DismissEvent, Entity, FocusHandle, Focusable, Task, WeakEntity};
 use picker::{Picker, PickerDelegate};
-use ui::{ListItem, prelude::*};
+use ui::{prelude::*, ListItem};
 
 use crate::context_picker::{ConfirmBehavior, ContextPicker};
 use crate::context_store::{self, ContextStore};
@@ -197,7 +197,7 @@ pub fn render_thread_context_entry(
                 .gap_1p5()
                 .max_w_72()
                 .child(
-                    Icon::new(IconName::MessageBubbles)
+                    Icon::new(IconName::MessageCircle)
                         .size(IconSize::XSmall)
                         .color(Color::Muted),
                 )

crates/assistant2/src/context_store.rs

@@ -1,23 +1,20 @@
-use std::ops::Range;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
 
-use anyhow::{Context as _, Result, anyhow};
+use anyhow::{anyhow, bail, Result};
 use collections::{BTreeMap, HashMap, HashSet};
-use futures::future::join_all;
-use futures::{self, Future, FutureExt, future};
-use gpui::{App, AppContext as _, Context, Entity, SharedString, Task, WeakEntity};
-use language::{Buffer, File};
-use project::{ProjectItem, ProjectPath, Worktree};
+use futures::{self, future, Future, FutureExt};
+use gpui::{App, AppContext as _, AsyncApp, Context, Entity, SharedString, Task, WeakEntity};
+use language::Buffer;
+use project::{ProjectPath, Worktree};
 use rope::Rope;
-use text::{Anchor, BufferId, OffsetRangeExt};
-use util::{ResultExt as _, maybe};
+use text::BufferId;
+use util::maybe;
 use workspace::Workspace;
 
-use crate::ThreadStore;
 use crate::context::{
-    AssistantContext, ContextBuffer, ContextId, ContextSymbol, ContextSymbolId, DirectoryContext,
-    FetchedUrlContext, FileContext, SymbolContext, ThreadContext,
+    AssistantContext, ContextBuffer, ContextId, ContextSnapshot, DirectoryContext,
+    FetchedUrlContext, FileContext, ThreadContext,
 };
 use crate::context_strip::SuggestedContext;
 use crate::thread::{Thread, ThreadId};
@@ -25,46 +22,35 @@ use crate::thread::{Thread, ThreadId};
 pub struct ContextStore {
     workspace: WeakEntity<Workspace>,
     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>,
-    symbols: HashMap<ContextSymbolId, ContextId>,
-    symbol_buffers: HashMap<ContextSymbolId, Entity<Buffer>>,
-    symbols_by_path: HashMap<ProjectPath, Vec<ContextSymbolId>>,
     threads: HashMap<ThreadId, ContextId>,
-    thread_summary_tasks: Vec<Task<()>>,
     fetched_urls: HashMap<String, ContextId>,
 }
 
 impl ContextStore {
-    pub fn new(
-        workspace: WeakEntity<Workspace>,
-        thread_store: Option<WeakEntity<ThreadStore>>,
-    ) -> Self {
+    pub fn new(workspace: WeakEntity<Workspace>) -> Self {
         Self {
             workspace,
-            thread_store,
             context: Vec::new(),
             next_context_id: ContextId(0),
             files: BTreeMap::default(),
             directories: HashMap::default(),
-            symbols: HashMap::default(),
-            symbol_buffers: HashMap::default(),
-            symbols_by_path: HashMap::default(),
             threads: HashMap::default(),
-            thread_summary_tasks: Vec::new(),
             fetched_urls: HashMap::default(),
         }
     }
 
-    pub fn context(&self) -> &Vec<AssistantContext> {
-        &self.context
+    pub fn snapshot<'a>(&'a self, cx: &'a App) -> impl Iterator<Item = ContextSnapshot> + 'a {
+        self.context()
+            .iter()
+            .flat_map(|context| context.snapshot(cx))
     }
 
-    pub fn context_for_id(&self, id: ContextId) -> Option<&AssistantContext> {
-        self.context().iter().find(|context| context.id() == id)
+    pub fn context(&self) -> &Vec<AssistantContext> {
+        &self.context
     }
 
     pub fn clear(&mut self) {
@@ -95,8 +81,8 @@ impl ContextStore {
                 project.open_buffer(project_path.clone(), cx)
             })?;
 
-            let buffer = open_buffer_task.await?;
-            let buffer_id = this.update(cx, |_, cx| buffer.read(cx).remote_id())?;
+            let buffer_entity = open_buffer_task.await?;
+            let buffer_id = this.update(cx, |_, cx| buffer_entity.read(cx).remote_id())?;
 
             let already_included = this.update(cx, |this, _cx| {
                 match this.will_include_buffer(buffer_id, &project_path.path) {
@@ -115,8 +101,15 @@ impl ContextStore {
                 return anyhow::Ok(());
             }
 
-            let (buffer_info, text_task) =
-                this.update(cx, |_, cx| collect_buffer_info_and_text(buffer, None, cx))??;
+            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,
+                    cx.to_async(),
+                )
+            })?;
 
             let text = text_task.await;
 
@@ -130,12 +123,22 @@ impl ContextStore {
 
     pub fn add_file_from_buffer(
         &mut self,
-        buffer: Entity<Buffer>,
+        buffer_entity: Entity<Buffer>,
         cx: &mut Context<Self>,
     ) -> Task<Result<()>> {
         cx.spawn(async move |this, cx| {
-            let (buffer_info, text_task) =
-                this.update(cx, |_, cx| collect_buffer_info_and_text(buffer, None, 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."));
+                };
+                Ok(collect_buffer_info_and_text(
+                    file.path().clone(),
+                    buffer_entity,
+                    buffer,
+                    cx.to_async(),
+                ))
+            })??;
 
             let text = text_task.await;
 
@@ -168,15 +171,14 @@ impl ContextStore {
             return Task::ready(Err(anyhow!("failed to read project")));
         };
 
-        let already_included = match self.includes_directory(&project_path.path) {
-            Some(FileInclusion::Direct(context_id)) => {
-                if remove_if_exists {
-                    self.remove_context(context_id);
-                }
-                true
+        let already_included = if let Some(context_id) = self.includes_directory(&project_path.path)
+        {
+            if remove_if_exists {
+                self.remove_context(context_id);
             }
-            Some(FileInclusion::InDirectory(_)) => true,
-            None => false,
+            true
+        } else {
+            false
         };
         if already_included {
             return Task::ready(Ok(()));
@@ -212,11 +214,16 @@ impl ContextStore {
             let mut buffer_infos = Vec::new();
             let mut text_tasks = Vec::new();
             this.update(cx, |_, cx| {
-                // 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()
-                    {
+                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);
+                        let (buffer_info, text_task) = collect_buffer_info_and_text(
+                            path,
+                            buffer_entity,
+                            buffer,
+                            cx.to_async(),
+                        );
                         buffer_infos.push(buffer_info);
                         text_tasks.push(text_task);
                     }
@@ -232,102 +239,27 @@ impl ContextStore {
                 .collect::<Vec<_>>();
 
             if context_buffers.is_empty() {
-                return Err(anyhow!(
-                    "No text files found in {}",
-                    &project_path.path.display()
-                ));
+                bail!("No text files found in {}", &project_path.path.display());
             }
 
             this.update(cx, |this, _| {
-                this.insert_directory(project_path, context_buffers);
+                this.insert_directory(&project_path.path, context_buffers);
             })?;
 
             anyhow::Ok(())
         })
     }
 
-    fn insert_directory(&mut self, project_path: ProjectPath, context_buffers: Vec<ContextBuffer>) {
+    fn insert_directory(&mut self, path: &Path, context_buffers: Vec<ContextBuffer>) {
         let id = self.next_context_id.post_inc();
-        self.directories.insert(project_path.path.to_path_buf(), id);
+        self.directories.insert(path.to_path_buf(), id);
 
         self.context
-            .push(AssistantContext::Directory(DirectoryContext {
+            .push(AssistantContext::Directory(DirectoryContext::new(
                 id,
-                project_path,
+                path,
                 context_buffers,
-            }));
-    }
-
-    pub fn add_symbol(
-        &mut self,
-        buffer: Entity<Buffer>,
-        symbol_name: SharedString,
-        symbol_range: Range<Anchor>,
-        symbol_enclosing_range: Range<Anchor>,
-        remove_if_exists: bool,
-        cx: &mut Context<Self>,
-    ) -> Task<Result<bool>> {
-        let buffer_ref = buffer.read(cx);
-        let Some(project_path) = buffer_ref.project_path(cx) else {
-            return Task::ready(Err(anyhow!("buffer has no path")));
-        };
-
-        if let Some(symbols_for_path) = self.symbols_by_path.get(&project_path) {
-            let mut matching_symbol_id = None;
-            for symbol in symbols_for_path {
-                if &symbol.name == &symbol_name {
-                    let snapshot = buffer_ref.snapshot();
-                    if symbol.range.to_offset(&snapshot) == symbol_range.to_offset(&snapshot) {
-                        matching_symbol_id = self.symbols.get(symbol).cloned();
-                        break;
-                    }
-                }
-            }
-
-            if let Some(id) = matching_symbol_id {
-                if remove_if_exists {
-                    self.remove_context(id);
-                }
-                return Task::ready(Ok(false));
-            }
-        }
-
-        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,
-                ))
-            })?;
-            anyhow::Ok(true)
-        })
-    }
-
-    fn insert_symbol(&mut self, context_symbol: ContextSymbol) {
-        let id = self.next_context_id.post_inc();
-        self.symbols.insert(context_symbol.id.clone(), id);
-        self.symbols_by_path
-            .entry(context_symbol.id.path.clone())
-            .or_insert_with(Vec::new)
-            .push(context_symbol.id.clone());
-        self.symbol_buffers
-            .insert(context_symbol.id.clone(), context_symbol.buffer.clone());
-        self.context.push(AssistantContext::Symbol(SymbolContext {
-            id,
-            context_symbol,
-        }));
+            )));
     }
 
     pub fn add_thread(
@@ -345,39 +277,9 @@ impl ContextStore {
         }
     }
 
-    pub fn wait_for_summaries(&mut self, cx: &App) -> Task<()> {
-        let tasks = std::mem::take(&mut self.thread_summary_tasks);
-
-        cx.spawn(async move |_cx| {
-            join_all(tasks).await;
-        })
-    }
-
-    fn insert_thread(&mut self, thread: Entity<Thread>, cx: &mut App) {
-        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| {
-                summary_task.await;
-
-                if let Some(thread_store) = thread_store {
-                    // Save thread so its summary can be reused later
-                    let save_task = thread_store
-                        .update(cx, |thread_store, cx| thread_store.save_thread(&thread, cx));
-
-                    if let Some(save_task) = save_task.ok() {
-                        save_task.await.log_err();
-                    }
-                }
-            }));
-        }
-
+    fn insert_thread(&mut self, thread: Entity<Thread>, cx: &App) {
         let id = self.next_context_id.post_inc();
-
-        let text = thread.read(cx).latest_detailed_summary_or_text();
+        let text = thread.read(cx).text().into();
 
         self.threads.insert(thread.read(cx).id().clone(), id);
         self.context
@@ -438,19 +340,6 @@ impl ContextStore {
             AssistantContext::Directory(_) => {
                 self.directories.retain(|_, context_id| *context_id != id);
             }
-            AssistantContext::Symbol(symbol) => {
-                if let Some(symbols_in_path) =
-                    self.symbols_by_path.get_mut(&symbol.context_symbol.id.path)
-                {
-                    symbols_in_path.retain(|s| {
-                        self.symbols
-                            .get(s)
-                            .map_or(false, |context_id| *context_id != id)
-                    });
-                }
-                self.symbol_buffers.remove(&symbol.context_symbol.id);
-                self.symbols.retain(|_, context_id| *context_id != id);
-            }
             AssistantContext::FetchedUrl(_) => {
                 self.fetched_urls.retain(|_, context_id| *context_id != id);
             }
@@ -478,7 +367,7 @@ impl ContextStore {
             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) {
+                    if let Some(file_path) = buffer_path_log_err(buffer) {
                         *file_path == *path
                     } else {
                         false
@@ -510,24 +399,8 @@ impl ContextStore {
         None
     }
 
-    pub fn includes_directory(&self, path: &Path) -> Option<FileInclusion> {
-        if let Some(context_id) = self.directories.get(path) {
-            return Some(FileInclusion::Direct(*context_id));
-        }
-
-        self.will_include_file_path_via_directory(path)
-    }
-
-    pub fn included_symbol(&self, symbol_id: &ContextSymbolId) -> Option<ContextId> {
-        self.symbols.get(symbol_id).copied()
-    }
-
-    pub fn included_symbols_by_path(&self) -> &HashMap<ProjectPath, Vec<ContextSymbolId>> {
-        &self.symbols_by_path
-    }
-
-    pub fn buffer_for_symbol(&self, symbol_id: &ContextSymbolId) -> Option<Entity<Buffer>> {
-        self.symbol_buffers.get(symbol_id).cloned()
+    pub fn includes_directory(&self, path: &Path) -> Option<ContextId> {
+        self.directories.get(path).copied()
     }
 
     pub fn includes_thread(&self, thread_id: &ThreadId) -> Option<ContextId> {
@@ -555,10 +428,9 @@ impl ContextStore {
             .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_path_log_err(buffer).map(|p| p.to_path_buf())
                 }
                 AssistantContext::Directory(_)
-                | AssistantContext::Symbol(_)
                 | AssistantContext::FetchedUrl(_)
                 | AssistantContext::Thread(_) => None,
             })
@@ -577,75 +449,40 @@ pub enum FileInclusion {
 
 // ContextBuffer without text.
 struct BufferInfo {
+    buffer_entity: Entity<Buffer>,
     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,
-        file: info.file,
+        buffer: info.buffer_entity,
         version: info.version,
         text,
     }
 }
 
-fn make_context_symbol(
-    info: BufferInfo,
-    path: ProjectPath,
-    name: SharedString,
-    range: Range<Anchor>,
-    enclosing_range: Range<Anchor>,
-    text: SharedString,
-) -> ContextSymbol {
-    ContextSymbol {
-        id: ContextSymbolId { name, range, path },
-        buffer_version: info.version,
-        enclosing_range,
-        buffer: info.buffer,
-        text,
-    }
-}
-
 fn collect_buffer_info_and_text(
-    buffer: Entity<Buffer>,
-    range: Option<Range<Anchor>>,
-    cx: &App,
-) -> Result<(BufferInfo, Task<SharedString>)> {
-    let buffer_ref = buffer.read(cx);
-    let file = buffer_ref.file().context("file context must have a 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 {
-        buffer_ref.as_rope().clone()
-    };
-
+    path: Arc<Path>,
+    buffer_entity: Entity<Buffer>,
+    buffer: &Buffer,
+    cx: AsyncApp,
+) -> (BufferInfo, Task<SharedString>) {
     let buffer_info = BufferInfo {
-        buffer,
-        id: buffer_ref.remote_id(),
-        file: file.clone(),
-        version,
+        id: buffer.remote_id(),
+        buffer_entity,
+        version: buffer.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))
+    // Important to collect version at the same time as content so that staleness logic is correct.
+    let content = buffer.as_rope().clone();
+    let text_task = cx.background_spawn(async move { to_fenced_codeblock(&path, content) });
+    (buffer_info, text_task)
 }
 
-pub fn buffer_path_log_err(buffer: &Buffer, cx: &App) -> Option<Arc<Path>> {
+pub fn buffer_path_log_err(buffer: &Buffer) -> 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)
+        Some(file.path().clone())
     } else {
         log::error!("Buffer that had a path unexpectedly no longer has a path.");
         None
@@ -710,7 +547,7 @@ pub fn refresh_context_store_text(
     context_store: Entity<ContextStore>,
     changed_buffers: &HashSet<Entity<Buffer>>,
     cx: &App,
-) -> impl Future<Output = Vec<ContextId>> + use<> {
+) -> impl Future<Output = Vec<ContextId>> {
     let mut tasks = Vec::new();
 
     for context in &context_store.read(cx).context {
@@ -731,9 +568,8 @@ pub fn refresh_context_store_text(
                         || 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)
-                            })
+                            buffer_path_log_err(&buffer)
+                                .map_or(false, |path| path.starts_with(&directory_context.path))
                         });
 
                     if should_refresh {
@@ -741,14 +577,6 @@ pub fn refresh_context_store_text(
                         return refresh_directory_text(context_store, directory_context, cx);
                     }
                 }
-                AssistantContext::Symbol(symbol_context) => {
-                    if changed_buffers.is_empty()
-                        || changed_buffers.contains(&symbol_context.context_symbol.buffer)
-                    {
-                        let context_store = context_store.clone();
-                        return refresh_symbol_text(context_store, symbol_context, cx);
-                    }
-                }
                 AssistantContext::Thread(thread_context) => {
                     if changed_buffers.is_empty() {
                         let context_store = context_store.clone();
@@ -819,45 +647,19 @@ 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 id = directory_context.snapshot.id;
+    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,
-                    context_buffers,
-                };
+                let new_directory_context = DirectoryContext::new(id, &path, context_buffers);
                 context_store.replace_context(AssistantContext::Directory(new_directory_context));
             })
             .ok();
     }))
 }
 
-fn refresh_symbol_text(
-    context_store: Entity<ContextStore>,
-    symbol_context: &SymbolContext,
-    cx: &App,
-) -> Option<Task<()>> {
-    let id = symbol_context.id;
-    let task = refresh_context_symbol(&symbol_context.context_symbol, cx);
-    if let Some(task) = task {
-        Some(cx.spawn(async move |cx| {
-            let context_symbol = task.await;
-            context_store
-                .update(cx, |context_store, _| {
-                    let new_symbol_context = SymbolContext { id, context_symbol };
-                    context_store.replace_context(AssistantContext::Symbol(new_symbol_context));
-                })
-                .ok();
-        }))
-    } else {
-        None
-    }
-}
-
 fn refresh_thread_text(
     context_store: Entity<ContextStore>,
     thread_context: &ThreadContext,
@@ -868,7 +670,7 @@ fn refresh_thread_text(
     cx.spawn(async move |cx| {
         context_store
             .update(cx, |context_store, cx| {
-                let text = thread.read(cx).latest_detailed_summary_or_text();
+                let text = thread.read(cx).text().into();
                 context_store.replace_context(AssistantContext::Thread(ThreadContext {
                     id,
                     thread,
@@ -882,44 +684,18 @@ fn refresh_thread_text(
 fn refresh_context_buffer(
     context_buffer: &ContextBuffer,
     cx: &App,
-) -> Option<impl Future<Output = ContextBuffer> + use<>> {
+) -> Option<impl Future<Output = ContextBuffer>> {
     let buffer = context_buffer.buffer.read(cx);
+    let path = buffer_path_log_err(buffer)?;
     if buffer.version.changed_since(&context_buffer.version) {
-        let (buffer_info, text_task) =
-            collect_buffer_info_and_text(context_buffer.buffer.clone(), None, cx).log_err()?;
+        let (buffer_info, text_task) = collect_buffer_info_and_text(
+            path,
+            context_buffer.buffer.clone(),
+            buffer,
+            cx.to_async(),
+        );
         Some(text_task.map(move |text| make_context_buffer(buffer_info, text)))
     } else {
         None
     }
 }
-
-fn refresh_context_symbol(
-    context_symbol: &ContextSymbol,
-    cx: &App,
-) -> Option<impl Future<Output = ContextSymbol> + use<>> {
-    let buffer = context_symbol.buffer.read(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(
-            context_symbol.buffer.clone(),
-            Some(context_symbol.enclosing_range.clone()),
-            cx,
-        )
-        .log_err()?;
-        let name = context_symbol.id.name.clone();
-        let range = context_symbol.id.range.clone();
-        let enclosing_range = context_symbol.enclosing_range.clone();
-        Some(text_task.map(move |text| {
-            make_context_symbol(
-                buffer_info,
-                project_path,
-                name,
-                range,
-                enclosing_range,
-                text,
-            )
-        }))
-    } else {
-        None
-    }
-}

crates/assistant2/src/context_strip.rs

@@ -4,20 +4,20 @@ use collections::HashSet;
 use editor::Editor;
 use file_icons::FileIcons;
 use gpui::{
-    App, Bounds, ClickEvent, DismissEvent, Entity, EventEmitter, FocusHandle, Focusable,
-    Subscription, WeakEntity,
+    App, Bounds, DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, Subscription,
+    WeakEntity,
 };
 use itertools::Itertools;
 use language::Buffer;
-use ui::{KeyBinding, PopoverMenu, PopoverMenuHandle, Tooltip, prelude::*};
-use workspace::{Workspace, notifications::NotifyResultExt};
+use ui::{prelude::*, KeyBinding, PopoverMenu, PopoverMenuHandle, Tooltip};
+use workspace::{notifications::NotifyResultExt, Workspace};
 
-use crate::context::{ContextId, ContextKind};
+use crate::context::ContextKind;
 use crate::context_picker::{ConfirmBehavior, ContextPicker};
 use crate::context_store::ContextStore;
 use crate::thread::Thread;
 use crate::thread_store::ThreadStore;
-use crate::ui::{AddedContext, ContextPill};
+use crate::ui::ContextPill;
 use crate::{
     AcceptSuggestedContext, AssistantPanel, FocusDown, FocusLeft, FocusRight, FocusUp,
     RemoveAllContext, RemoveFocusedContext, ToggleContextPicker,
@@ -92,12 +92,12 @@ 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 path = active_buffer.file()?.path();
 
         if self
             .context_store
             .read(cx)
-            .will_include_buffer(active_buffer.remote_id(), &path)
+            .will_include_buffer(active_buffer.remote_id(), path)
             .is_some()
         {
             return None;
@@ -108,7 +108,7 @@ impl ContextStrip {
             None => path.to_string_lossy().into_owned().into(),
         };
 
-        let icon_path = FileIcons::get_icon(&path, cx);
+        let icon_path = FileIcons::get_icon(path, cx);
 
         Some(SuggestedContext::File {
             name,
@@ -239,7 +239,11 @@ impl ContextStrip {
         let eraser = if bounds.len() < 3 { 0 } else { 1 };
         let pills = &bounds[1..bounds.len() - eraser];
 
-        if pills.is_empty() { None } else { Some(pills) }
+        if pills.is_empty() {
+            None
+        } else {
+            Some(pills)
+        }
     }
 
     fn last_pill_index(&self) -> Option<usize> {
@@ -273,14 +277,6 @@ impl ContextStrip {
         best.map(|(index, _, _)| index)
     }
 
-    fn open_context(&mut self, id: ContextId, window: &mut Window, cx: &mut App) {
-        let Some(workspace) = self.workspace.upgrade() else {
-            return;
-        };
-
-        crate::active_thread::open_context(id, self.context_store.clone(), workspace, window, cx);
-    }
-
     fn remove_focused_context(
         &mut self,
         _: &RemoveFocusedContext,
@@ -363,19 +359,19 @@ impl Focusable for ContextStrip {
 impl Render for ContextStrip {
     fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
         let context_store = self.context_store.read(cx);
-        let context = context_store.context();
+        let context = context_store
+            .context()
+            .iter()
+            .flat_map(|context| context.snapshot(cx))
+            .collect::<Vec<_>>();
         let context_picker = self.context_picker.clone();
         let focus_handle = self.focus_handle.clone();
 
         let suggested_context = self.suggested_context(cx);
 
-        let added_contexts = context
+        let dupe_names = context
             .iter()
-            .map(|c| AddedContext::new(c, cx))
-            .collect::<Vec<_>>();
-        let dupe_names = added_contexts
-            .iter()
-            .map(|c| c.name.clone())
+            .map(|context| context.name.clone())
             .sorted()
             .tuple_windows()
             .filter(|(a, b)| a == b)
@@ -461,39 +457,27 @@ impl Render for ContextStrip {
                     )
                 }
             })
-            .children(
-                added_contexts
-                    .into_iter()
-                    .enumerate()
-                    .map(|(i, added_context)| {
-                        let name = added_context.name.clone();
-                        let id = added_context.id;
-                        ContextPill::added(
-                            added_context,
-                            dupe_names.contains(&name),
-                            self.focused_index == Some(i),
-                            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);
-                                    });
-                                    cx.notify();
-                                }))
-                            }),
-                        )
-                        .on_click({
-                            Rc::new(cx.listener(move |this, event: &ClickEvent, window, cx| {
-                                if event.down.click_count > 1 {
-                                    this.open_context(id, window, cx);
-                                } else {
-                                    this.focused_index = Some(i);
-                                }
-                                cx.notify();
-                            }))
-                        })
+            .children(context.iter().enumerate().map(|(i, context)| {
+                ContextPill::added(
+                    context.clone(),
+                    dupe_names.contains(&context.name),
+                    self.focused_index == Some(i),
+                    Some({
+                        let id = context.id;
+                        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);
+                            });
+                            cx.notify();
+                        }))
                     }),
-            )
+                )
+                .on_click(Rc::new(cx.listener(move |this, _, _window, cx| {
+                    this.focused_index = Some(i);
+                    cx.notify();
+                })))
+            }))
             .when_some(suggested_context, |el, suggested| {
                 el.child(
                     ContextPill::suggested(

crates/assistant2/src/history_store.rs

@@ -1,10 +1,9 @@
 use assistant_context_editor::SavedContextMetadata;
 use chrono::{DateTime, Utc};
-use gpui::{Entity, prelude::*};
+use gpui::{prelude::*, Entity};
 
 use crate::thread_store::{SerializedThreadMetadata, ThreadStore};
 
-#[derive(Debug)]
 pub enum HistoryEntry {
     Thread(SerializedThreadMetadata),
     Context(SavedContextMetadata),
@@ -22,35 +21,28 @@ 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();
 
-        #[cfg(debug_assertions)]
-        if std::env::var("ZED_SIMULATE_NO_THREAD_HISTORY").is_ok() {
-            return history_entries;
-        }
-
         for thread in self.thread_store.update(cx, |this, _cx| this.threads()) {
             history_entries.push(HistoryEntry::Thread(thread));
         }

crates/assistant2/src/inline_assistant.rs

@@ -7,24 +7,24 @@ use std::sync::Arc;
 use anyhow::{Context as _, Result};
 use assistant_settings::AssistantSettings;
 use client::telemetry::Telemetry;
-use collections::{HashMap, HashSet, VecDeque, hash_map};
+use collections::{hash_map, HashMap, HashSet, VecDeque};
 use editor::{
-    Anchor, AnchorRangeExt, CodeActionProvider, Editor, EditorEvent, ExcerptId, ExcerptRange,
-    GutterDimensions, MultiBuffer, MultiBufferSnapshot, ToOffset as _, ToPoint,
     actions::SelectAll,
     display_map::{
         BlockContext, BlockPlacement, BlockProperties, BlockStyle, CustomBlockId, RenderBlock,
         ToDisplayPoint,
     },
+    Anchor, AnchorRangeExt, CodeActionProvider, Editor, EditorEvent, ExcerptId, ExcerptRange,
+    GutterDimensions, MultiBuffer, MultiBufferSnapshot, ToOffset as _, ToPoint,
 };
 use feature_flags::{Assistant2FeatureFlag, FeatureFlagViewExt as _};
 use fs::Fs;
 use gpui::{
-    App, Context, Entity, Focusable, Global, HighlightStyle, Subscription, Task, UpdateGlobal,
-    WeakEntity, Window, point,
+    point, App, Context, Entity, Focusable, Global, HighlightStyle, Subscription, Task,
+    UpdateGlobal, WeakEntity, Window,
 };
 use language::{Buffer, Point, Selection, TransactionId};
-use language_model::{LanguageModelRegistry, report_assistant_event};
+use language_model::{report_assistant_event, LanguageModelRegistry};
 use multi_buffer::MultiBufferRow;
 use parking_lot::Mutex;
 use project::LspAction;
@@ -32,20 +32,20 @@ use project::{CodeAction, ProjectTransaction};
 use prompt_store::PromptBuilder;
 use settings::{Settings, SettingsStore};
 use telemetry_events::{AssistantEvent, AssistantKind, AssistantPhase};
-use terminal_view::{TerminalView, terminal_panel::TerminalPanel};
+use terminal_view::{terminal_panel::TerminalPanel, TerminalView};
 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::{dock::Panel, ShowConfiguration};
+use workspace::{notifications::NotificationId, ItemHandle, Toast, Workspace};
 
-use crate::AssistantPanel;
 use crate::buffer_codegen::{BufferCodegen, CodegenAlternative, CodegenEvent};
 use crate::context_store::ContextStore;
 use crate::inline_prompt_editor::{CodegenStatus, InlineAssistId, PromptEditor, PromptEditorEvent};
 use crate::terminal_inline_assistant::TerminalInlineAssistant;
 use crate::thread_store::ThreadStore;
+use crate::AssistantPanel;
 
 pub fn init(
     fs: Arc<dyn Fs>,
@@ -239,8 +239,8 @@ impl InlineAssistant {
 
         let is_authenticated = || {
             LanguageModelRegistry::read_global(cx)
-                .inline_assistant_model()
-                .map_or(false, |model| model.provider.is_authenticated(cx))
+                .active_provider()
+                .map_or(false, |provider| provider.is_authenticated(cx))
         };
 
         let thread_store = workspace
@@ -279,8 +279,8 @@ impl InlineAssistant {
             cx.spawn_in(window, async move |_workspace, cx| {
                 let Some(task) = cx.update(|_, cx| {
                     LanguageModelRegistry::read_global(cx)
-                        .inline_assistant_model()
-                        .map_or(None, |model| Some(model.provider.authenticate(cx)))
+                        .active_provider()
+                        .map_or(None, |provider| Some(provider.authenticate(cx)))
                 })?
                 else {
                     let answer = cx
@@ -401,14 +401,14 @@ impl InlineAssistant {
 
             codegen_ranges.push(anchor_range);
 
-            if let Some(model) = LanguageModelRegistry::read_global(cx).inline_assistant_model() {
+            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
                 self.telemetry.report_assistant_event(AssistantEvent {
                     conversation_id: None,
                     kind: AssistantKind::Inline,
                     phase: AssistantPhase::Invoked,
                     message_id: None,
-                    model: model.model.telemetry_id(),
-                    model_provider: model.provider.id().to_string(),
+                    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()),
@@ -424,8 +424,7 @@ impl InlineAssistant {
         let mut assist_to_focus = None;
         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()));
+            let context_store = cx.new(|_cx| ContextStore::new(workspace.clone()));
             let codegen = cx.new(|cx| {
                 BufferCodegen::new(
                     editor.read(cx).buffer().clone(),
@@ -537,8 +536,7 @@ impl InlineAssistant {
             range.end = range.end.bias_right(&snapshot);
         }
 
-        let context_store =
-            cx.new(|_cx| ContextStore::new(workspace.clone(), thread_store.clone()));
+        let context_store = cx.new(|_cx| ContextStore::new(workspace.clone()));
 
         let codegen = cx.new(|cx| {
             BufferCodegen::new(
@@ -976,7 +974,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).inline_assistant_model() {
+            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
                 let language_name = assist.editor.upgrade().and_then(|editor| {
                     let multibuffer = editor.read(cx).buffer().read(cx);
                     let snapshot = multibuffer.snapshot(cx);
@@ -996,15 +994,15 @@ impl InlineAssistant {
                         } else {
                             AssistantPhase::Accepted
                         },
-                        model: model.model.telemetry_id(),
-                        model_provider: model.model.provider_id().to_string(),
+                        model: model.telemetry_id(),
+                        model_provider: 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.model.api_key(cx),
+                    model.api_key(cx),
                     cx.background_executor(),
                 );
             }
@@ -1365,7 +1363,10 @@ impl InlineAssistant {
                     multi_buffer.update(cx, |multi_buffer, cx| {
                         multi_buffer.push_excerpts(
                             old_buffer.clone(),
-                            Some(ExcerptRange::new(buffer_start..buffer_end)),
+                            Some(ExcerptRange {
+                                context: buffer_start..buffer_end,
+                                primary: None,
+                            }),
                             cx,
                         );
                     });

crates/assistant2/src/inline_prompt_editor.rs

@@ -1,4 +1,4 @@
-use crate::assistant_model_selector::{AssistantModelSelector, ModelType};
+use crate::assistant_model_selector::AssistantModelSelector;
 use crate::buffer_codegen::BufferCodegen;
 use crate::context_picker::ContextPicker;
 use crate::context_store::ContextStore;
@@ -10,14 +10,14 @@ use crate::{RemoveAllContext, ToggleContextPicker};
 use client::ErrorExt;
 use collections::VecDeque;
 use editor::{
-    Editor, EditorElement, EditorEvent, EditorMode, EditorStyle, GutterDimensions, MultiBuffer,
     actions::{MoveDown, MoveUp},
+    Editor, EditorElement, EditorEvent, EditorMode, EditorStyle, GutterDimensions, MultiBuffer,
 };
 use feature_flags::{FeatureFlagAppExt as _, ZedPro};
 use fs::Fs;
 use gpui::{
-    AnyElement, App, ClickEvent, Context, CursorStyle, Entity, EventEmitter, FocusHandle,
-    Focusable, FontWeight, Subscription, TextStyle, WeakEntity, Window, anchored, deferred, point,
+    anchored, deferred, point, AnyElement, App, ClickEvent, Context, CursorStyle, Entity,
+    EventEmitter, FocusHandle, Focusable, FontWeight, Subscription, TextStyle, WeakEntity, Window,
 };
 use language_model::{LanguageModel, LanguageModelRegistry};
 use language_model_selector::ToggleModelSelector;
@@ -28,7 +28,7 @@ use std::sync::Arc;
 use theme::ThemeSettings;
 use ui::utils::WithRemSize;
 use ui::{
-    CheckboxWithLabel, IconButtonShape, KeyBinding, Popover, PopoverMenuHandle, Tooltip, prelude::*,
+    prelude::*, CheckboxWithLabel, IconButtonShape, KeyBinding, Popover, PopoverMenuHandle, Tooltip,
 };
 use util::ResultExt;
 use workspace::Workspace;
@@ -455,55 +455,47 @@ impl<T: 'static> PromptEditor<T> {
 
         match codegen_status {
             CodegenStatus::Idle => {
-                vec![
-                    Button::new("start", mode.start_label())
-                        .label_size(LabelSize::Small)
-                        .icon(IconName::Return)
-                        .icon_size(IconSize::XSmall)
-                        .icon_color(Color::Muted)
-                        .on_click(
-                            cx.listener(|_, _, _, cx| cx.emit(PromptEditorEvent::StartRequested)),
-                        )
-                        .into_any_element(),
-                ]
+                vec![Button::new("start", mode.start_label())
+                    .label_size(LabelSize::Small)
+                    .icon(IconName::Return)
+                    .icon_size(IconSize::XSmall)
+                    .icon_color(Color::Muted)
+                    .on_click(cx.listener(|_, _, _, cx| cx.emit(PromptEditorEvent::StartRequested)))
+                    .into_any_element()]
             }
-            CodegenStatus::Pending => vec![
-                IconButton::new("stop", IconName::Stop)
-                    .icon_color(Color::Error)
-                    .shape(IconButtonShape::Square)
-                    .tooltip(move |window, cx| {
-                        Tooltip::with_meta(
-                            mode.tooltip_interrupt(),
-                            Some(&menu::Cancel),
-                            "Changes won't be discarded",
-                            window,
-                            cx,
-                        )
-                    })
-                    .on_click(cx.listener(|_, _, _, cx| cx.emit(PromptEditorEvent::StopRequested)))
-                    .into_any_element(),
-            ],
+            CodegenStatus::Pending => vec![IconButton::new("stop", IconName::Stop)
+                .icon_color(Color::Error)
+                .shape(IconButtonShape::Square)
+                .tooltip(move |window, cx| {
+                    Tooltip::with_meta(
+                        mode.tooltip_interrupt(),
+                        Some(&menu::Cancel),
+                        "Changes won't be discarded",
+                        window,
+                        cx,
+                    )
+                })
+                .on_click(cx.listener(|_, _, _, cx| cx.emit(PromptEditorEvent::StopRequested)))
+                .into_any_element()],
             CodegenStatus::Done | CodegenStatus::Error(_) => {
                 let has_error = matches!(codegen_status, CodegenStatus::Error(_));
                 if has_error || self.edited_since_done {
-                    vec![
-                        IconButton::new("restart", IconName::RotateCw)
-                            .icon_color(Color::Info)
-                            .shape(IconButtonShape::Square)
-                            .tooltip(move |window, cx| {
-                                Tooltip::with_meta(
-                                    mode.tooltip_restart(),
-                                    Some(&menu::Confirm),
-                                    "Changes will be discarded",
-                                    window,
-                                    cx,
-                                )
-                            })
-                            .on_click(cx.listener(|_, _, _, cx| {
-                                cx.emit(PromptEditorEvent::StartRequested);
-                            }))
-                            .into_any_element(),
-                    ]
+                    vec![IconButton::new("restart", IconName::RotateCw)
+                        .icon_color(Color::Info)
+                        .shape(IconButtonShape::Square)
+                        .tooltip(move |window, cx| {
+                            Tooltip::with_meta(
+                                mode.tooltip_restart(),
+                                Some(&menu::Confirm),
+                                "Changes will be discarded",
+                                window,
+                                cx,
+                            )
+                        })
+                        .on_click(cx.listener(|_, _, _, cx| {
+                            cx.emit(PromptEditorEvent::StartRequested);
+                        }))
+                        .into_any_element()]
                 } else {
                     let accept = IconButton::new("accept", IconName::Check)
                         .icon_color(Color::Info)
@@ -582,7 +574,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.default_model().map(|default| default.model);
+        let default_model = model_registry.active_model();
         let alternative_models = model_registry.inline_alternative_models();
 
         let get_model_name = |index: usize| -> String {
@@ -890,7 +882,6 @@ impl PromptEditor<BufferCodegen> {
                     fs,
                     model_selector_menu_handle,
                     prompt_editor.focus_handle(cx),
-                    ModelType::InlineAssistant,
                     window,
                     cx,
                 )
@@ -1043,7 +1034,6 @@ impl PromptEditor<TerminalCodegen> {
                     fs,
                     model_selector_menu_handle.clone(),
                     prompt_editor.focus_handle(cx),
-                    ModelType::InlineAssistant,
                     window,
                     cx,
                 )

crates/assistant2/src/message_editor.rs

@@ -0,0 +1,686 @@
+use std::sync::Arc;
+
+use collections::HashSet;
+use editor::actions::MoveUp;
+use editor::{ContextMenuOptions, ContextMenuPlacement, Editor, EditorElement, EditorStyle};
+use fs::Fs;
+use git::ExpandCommitEditor;
+use git_ui::git_panel;
+use gpui::{
+    point, Animation, AnimationExt, App, DismissEvent, Entity, Focusable, Subscription, TextStyle,
+    WeakEntity,
+};
+use language_model::LanguageModelRegistry;
+use language_model_selector::ToggleModelSelector;
+use project::Project;
+use settings::Settings;
+use std::time::Duration;
+use theme::ThemeSettings;
+use ui::{
+    prelude::*, ButtonLike, KeyBinding, PlatformStyle, PopoverMenu, PopoverMenuHandle, Tooltip,
+};
+use vim_mode_setting::VimModeSetting;
+use workspace::Workspace;
+
+use crate::assistant_model_selector::AssistantModelSelector;
+use crate::context_picker::{ConfirmBehavior, ContextPicker, ContextPickerCompletionProvider};
+use crate::context_store::{refresh_context_store_text, ContextStore};
+use crate::context_strip::{ContextStrip, ContextStripEvent, SuggestContextKind};
+use crate::profile_selector::ProfileSelector;
+use crate::thread::{RequestKind, Thread};
+use crate::thread_store::ThreadStore;
+use crate::{Chat, ChatMode, RemoveAllContext, ThreadEvent, ToggleContextPicker};
+
+pub struct MessageEditor {
+    thread: Entity<Thread>,
+    editor: Entity<Editor>,
+    #[allow(dead_code)]
+    workspace: WeakEntity<Workspace>,
+    project: Entity<Project>,
+    context_store: Entity<ContextStore>,
+    context_strip: Entity<ContextStrip>,
+    context_picker_menu_handle: PopoverMenuHandle<ContextPicker>,
+    inline_context_picker: Entity<ContextPicker>,
+    inline_context_picker_menu_handle: PopoverMenuHandle<ContextPicker>,
+    model_selector: Entity<AssistantModelSelector>,
+    profile_selector: Entity<ProfileSelector>,
+    _subscriptions: Vec<Subscription>,
+}
+
+impl MessageEditor {
+    pub fn new(
+        fs: Arc<dyn Fs>,
+        workspace: WeakEntity<Workspace>,
+        context_store: Entity<ContextStore>,
+        thread_store: WeakEntity<ThreadStore>,
+        thread: Entity<Thread>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let context_picker_menu_handle = PopoverMenuHandle::default();
+        let inline_context_picker_menu_handle = PopoverMenuHandle::default();
+        let model_selector_menu_handle = PopoverMenuHandle::default();
+
+        let editor = cx.new(|cx| {
+            let mut editor = Editor::auto_height(10, window, cx);
+            editor.set_placeholder_text("Ask anything, @ to mention, ↑ to select", cx);
+            editor.set_show_indent_guides(false, cx);
+            editor.set_context_menu_options(ContextMenuOptions {
+                min_entries_visible: 12,
+                max_entries_visible: 12,
+                placement: Some(ContextMenuPlacement::Above),
+            });
+
+            editor
+        });
+
+        let editor_entity = editor.downgrade();
+        editor.update(cx, |editor, _| {
+            editor.set_completion_provider(Some(Box::new(ContextPickerCompletionProvider::new(
+                workspace.clone(),
+                context_store.downgrade(),
+                Some(thread_store.clone()),
+                editor_entity,
+            ))));
+        });
+
+        let inline_context_picker = cx.new(|cx| {
+            ContextPicker::new(
+                workspace.clone(),
+                Some(thread_store.clone()),
+                context_store.downgrade(),
+                ConfirmBehavior::Close,
+                window,
+                cx,
+            )
+        });
+
+        let context_strip = cx.new(|cx| {
+            ContextStrip::new(
+                context_store.clone(),
+                workspace.clone(),
+                Some(thread_store.clone()),
+                context_picker_menu_handle.clone(),
+                SuggestContextKind::File,
+                window,
+                cx,
+            )
+        });
+
+        let subscriptions = vec![
+            cx.subscribe_in(
+                &inline_context_picker,
+                window,
+                Self::handle_inline_context_picker_event,
+            ),
+            cx.subscribe_in(&context_strip, window, Self::handle_context_strip_event),
+        ];
+
+        Self {
+            editor: editor.clone(),
+            project: thread.read(cx).project().clone(),
+            thread,
+            workspace,
+            context_store,
+            context_strip,
+            context_picker_menu_handle,
+            inline_context_picker,
+            inline_context_picker_menu_handle,
+            model_selector: cx.new(|cx| {
+                AssistantModelSelector::new(
+                    fs.clone(),
+                    model_selector_menu_handle,
+                    editor.focus_handle(cx),
+                    window,
+                    cx,
+                )
+            }),
+            profile_selector: cx.new(|cx| ProfileSelector::new(fs, thread_store, cx)),
+            _subscriptions: subscriptions,
+        }
+    }
+
+    fn toggle_chat_mode(&mut self, _: &ChatMode, _window: &mut Window, cx: &mut Context<Self>) {
+        cx.notify();
+    }
+
+    fn toggle_context_picker(
+        &mut self,
+        _: &ToggleContextPicker,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.context_picker_menu_handle.toggle(window, cx);
+    }
+    pub fn remove_all_context(
+        &mut self,
+        _: &RemoveAllContext,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.context_store.update(cx, |store, _cx| store.clear());
+        cx.notify();
+    }
+
+    fn chat(&mut self, _: &Chat, window: &mut Window, cx: &mut Context<Self>) {
+        if self.is_editor_empty(cx) {
+            return;
+        }
+
+        if self.thread.read(cx).is_generating() {
+            return;
+        }
+
+        self.send_to_model(RequestKind::Chat, window, cx);
+    }
+
+    fn is_editor_empty(&self, cx: &App) -> bool {
+        self.editor.read(cx).text(cx).is_empty()
+    }
+
+    fn is_model_selected(&self, cx: &App) -> bool {
+        LanguageModelRegistry::read_global(cx)
+            .active_model()
+            .is_some()
+    }
+
+    fn send_to_model(
+        &mut self,
+        request_kind: RequestKind,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let provider = LanguageModelRegistry::read_global(cx).active_provider();
+        if provider
+            .as_ref()
+            .map_or(false, |provider| provider.must_accept_terms(cx))
+        {
+            cx.notify();
+            return;
+        }
+
+        let model_registry = LanguageModelRegistry::read_global(cx);
+        let Some(model) = model_registry.active_model() else {
+            return;
+        };
+
+        let user_message = self.editor.update(cx, |editor, cx| {
+            let text = editor.text(cx);
+            editor.clear(window, cx);
+            text
+        });
+
+        let refresh_task =
+            refresh_context_store_text(self.context_store.clone(), &HashSet::default(), cx);
+
+        let system_prompt_context_task = self.thread.read(cx).load_system_prompt_context(cx);
+
+        let thread = self.thread.clone();
+        let context_store = self.context_store.clone();
+        let checkpoint = self.project.read(cx).git_store().read(cx).checkpoint(cx);
+        cx.spawn(async move |_, cx| {
+            let checkpoint = checkpoint.await.ok();
+            refresh_task.await;
+            let (system_prompt_context, load_error) = system_prompt_context_task.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
+                .update(cx, |thread, cx| {
+                    let context = context_store.read(cx).snapshot(cx).collect::<Vec<_>>();
+                    thread.insert_user_message(user_message, context, checkpoint, cx);
+                    thread.send_to_model(model, request_kind, cx);
+                })
+                .ok();
+        })
+        .detach();
+    }
+
+    fn handle_inline_context_picker_event(
+        &mut self,
+        _inline_context_picker: &Entity<ContextPicker>,
+        _event: &DismissEvent,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let editor_focus_handle = self.editor.focus_handle(cx);
+        window.focus(&editor_focus_handle);
+    }
+
+    fn handle_context_strip_event(
+        &mut self,
+        _context_strip: &Entity<ContextStrip>,
+        event: &ContextStripEvent,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        match event {
+            ContextStripEvent::PickerDismissed
+            | ContextStripEvent::BlurredEmpty
+            | ContextStripEvent::BlurredDown => {
+                let editor_focus_handle = self.editor.focus_handle(cx);
+                window.focus(&editor_focus_handle);
+            }
+            ContextStripEvent::BlurredUp => {}
+        }
+    }
+
+    fn move_up(&mut self, _: &MoveUp, window: &mut Window, cx: &mut Context<Self>) {
+        if self.context_picker_menu_handle.is_deployed()
+            || self.inline_context_picker_menu_handle.is_deployed()
+        {
+            cx.propagate();
+        } else {
+            self.context_strip.focus_handle(cx).focus(window);
+        }
+    }
+}
+
+impl Focusable for MessageEditor {
+    fn focus_handle(&self, cx: &App) -> gpui::FocusHandle {
+        self.editor.focus_handle(cx)
+    }
+}
+
+impl Render for MessageEditor {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let font_size = TextSize::Default.rems(cx);
+        let line_height = font_size.to_pixels(window.rem_size()) * 1.5;
+
+        let focus_handle = self.editor.focus_handle(cx);
+        let inline_context_picker = self.inline_context_picker.clone();
+
+        let empty_thread = self.thread.read(cx).is_empty();
+        let is_generating = self.thread.read(cx).is_generating();
+        let is_model_selected = self.is_model_selected(cx);
+        let is_editor_empty = self.is_editor_empty(cx);
+        let submit_label_color = if is_editor_empty {
+            Color::Muted
+        } else {
+            Color::Default
+        };
+
+        let vim_mode_enabled = VimModeSetting::get_global(cx).0;
+        let platform = PlatformStyle::platform();
+        let linux = platform == PlatformStyle::Linux;
+        let windows = platform == PlatformStyle::Windows;
+        let button_width = if linux || windows || vim_mode_enabled {
+            px(82.)
+        } else {
+            px(64.)
+        };
+
+        let project = self.thread.read(cx).project();
+        let changed_files = if let Some(repository) = project.read(cx).active_repository(cx) {
+            repository.read(cx).cached_status().count()
+        } else {
+            0
+        };
+
+        let border_color = cx.theme().colors().border;
+        let active_color = cx.theme().colors().element_selected;
+        let editor_bg_color = cx.theme().colors().editor_background;
+        let bg_edit_files_disclosure = editor_bg_color.blend(active_color.opacity(0.3));
+
+        let edit_files_container = || {
+            h_flex()
+                .mx_2()
+                .py_1()
+                .pl_2p5()
+                .pr_1()
+                .bg(bg_edit_files_disclosure)
+                .border_1()
+                .border_color(border_color)
+                .justify_between()
+                .flex_wrap()
+        };
+
+        v_flex()
+            .size_full()
+            .when(is_generating, |parent| {
+                let focus_handle = self.editor.focus_handle(cx).clone();
+                parent.child(
+                    h_flex().py_3().w_full().justify_center().child(
+                        h_flex()
+                            .flex_none()
+                            .pl_2()
+                            .pr_1()
+                            .py_1()
+                            .bg(editor_bg_color)
+                            .border_1()
+                            .border_color(cx.theme().colors().border_variant)
+                            .rounded_lg()
+                            .shadow_md()
+                            .gap_1()
+                            .child(
+                                Icon::new(IconName::ArrowCircle)
+                                    .size(IconSize::XSmall)
+                                    .color(Color::Muted)
+                                    .with_animation(
+                                        "arrow-circle",
+                                        Animation::new(Duration::from_secs(2)).repeat(),
+                                        |icon, delta| {
+                                            icon.transform(gpui::Transformation::rotate(
+                                                gpui::percentage(delta),
+                                            ))
+                                        },
+                                    ),
+                            )
+                            .child(
+                                Label::new("Generating…")
+                                    .size(LabelSize::XSmall)
+                                    .color(Color::Muted),
+                            )
+                            .child(ui::Divider::vertical())
+                            .child(
+                                Button::new("cancel-generation", "Cancel")
+                                    .label_size(LabelSize::XSmall)
+                                    .key_binding(
+                                        KeyBinding::for_action_in(
+                                            &editor::actions::Cancel,
+                                            &focus_handle,
+                                            window,
+                                            cx,
+                                        )
+                                        .map(|kb| kb.size(rems_from_px(10.))),
+                                    )
+                                    .on_click(move |_event, window, cx| {
+                                        focus_handle.dispatch_action(
+                                            &editor::actions::Cancel,
+                                            window,
+                                            cx,
+                                        );
+                                    }),
+                            ),
+                    ),
+                )
+            })
+            .when(
+                changed_files > 0 && !is_generating && !empty_thread,
+                |parent| {
+                    parent.child(
+                        edit_files_container()
+                            .border_b_0()
+                            .rounded_t_md()
+                            .shadow(smallvec::smallvec![gpui::BoxShadow {
+                                color: gpui::black().opacity(0.15),
+                                offset: point(px(1.), px(-1.)),
+                                blur_radius: px(3.),
+                                spread_radius: px(0.),
+                            }])
+                            .child(
+                                h_flex()
+                                    .gap_2()
+                                    .child(Label::new("Edits").size(LabelSize::XSmall))
+                                    .child(div().size_1().rounded_full().bg(border_color))
+                                    .child(
+                                        Label::new(format!(
+                                            "{} {}",
+                                            changed_files,
+                                            if changed_files == 1 { "file" } else { "files" }
+                                        ))
+                                        .size(LabelSize::XSmall),
+                                    ),
+                            )
+                            .child(
+                                h_flex()
+                                    .gap_1()
+                                    .child(
+                                        Button::new("panel", "Open Git Panel")
+                                            .label_size(LabelSize::XSmall)
+                                            .key_binding({
+                                                let focus_handle = focus_handle.clone();
+                                                KeyBinding::for_action_in(
+                                                    &git_panel::ToggleFocus,
+                                                    &focus_handle,
+                                                    window,
+                                                    cx,
+                                                )
+                                                .map(|kb| kb.size(rems_from_px(10.)))
+                                            })
+                                            .on_click(|_ev, _window, cx| {
+                                                cx.defer(|cx| {
+                                                    cx.dispatch_action(&git_panel::ToggleFocus)
+                                                });
+                                            }),
+                                    )
+                                    .child(
+                                        Button::new("review", "Review Diff")
+                                            .label_size(LabelSize::XSmall)
+                                            .key_binding({
+                                                let focus_handle = focus_handle.clone();
+                                                KeyBinding::for_action_in(
+                                                    &git_ui::project_diff::Diff,
+                                                    &focus_handle,
+                                                    window,
+                                                    cx,
+                                                )
+                                                .map(|kb| kb.size(rems_from_px(10.)))
+                                            })
+                                            .on_click(|_event, _window, cx| {
+                                                cx.defer(|cx| {
+                                                    cx.dispatch_action(&git_ui::project_diff::Diff)
+                                                });
+                                            }),
+                                    )
+                                    .child(
+                                        Button::new("commit", "Commit Changes")
+                                            .label_size(LabelSize::XSmall)
+                                            .key_binding({
+                                                let focus_handle = focus_handle.clone();
+                                                KeyBinding::for_action_in(
+                                                    &ExpandCommitEditor,
+                                                    &focus_handle,
+                                                    window,
+                                                    cx,
+                                                )
+                                                .map(|kb| kb.size(rems_from_px(10.)))
+                                            })
+                                            .on_click(|_event, _window, cx| {
+                                                cx.defer(|cx| {
+                                                    cx.dispatch_action(&ExpandCommitEditor)
+                                                });
+                                            }),
+                                    ),
+                            ),
+                    )
+                },
+            )
+            .when(
+                changed_files > 0 && !is_generating && empty_thread,
+                |parent| {
+                    parent.child(
+                        edit_files_container()
+                            .mb_2()
+                            .rounded_md()
+                            .child(
+                                h_flex()
+                                    .gap_2()
+                                    .child(Label::new("Consider committing your changes before starting a fresh thread").size(LabelSize::XSmall))
+                                    .child(div().size_1().rounded_full().bg(border_color))
+                                    .child(
+                                        Label::new(format!(
+                                            "{} {}",
+                                            changed_files,
+                                            if changed_files == 1 { "file" } else { "files" }
+                                        ))
+                                        .size(LabelSize::XSmall),
+                                    ),
+                            )
+                            .child(
+                                h_flex()
+                                    .gap_1()
+                                    .child(
+                                        Button::new("review", "Review Diff")
+                                            .label_size(LabelSize::XSmall)
+                                            .key_binding({
+                                                let focus_handle = focus_handle.clone();
+                                                KeyBinding::for_action_in(
+                                                    &git_ui::project_diff::Diff,
+                                                    &focus_handle,
+                                                    window,
+                                                    cx,
+                                                )
+                                                .map(|kb| kb.size(rems_from_px(10.)))
+                                            })
+                                            .on_click(|_event, _window, cx| {
+                                                cx.defer(|cx| {
+                                                    cx.dispatch_action(&git_ui::project_diff::Diff)
+                                                });
+                                            }),
+                                    )
+                                    .child(
+                                        Button::new("commit", "Commit Changes")
+                                            .label_size(LabelSize::XSmall)
+                                            .key_binding({
+                                                let focus_handle = focus_handle.clone();
+                                                KeyBinding::for_action_in(
+                                                    &ExpandCommitEditor,
+                                                    &focus_handle,
+                                                    window,
+                                                    cx,
+                                                )
+                                                .map(|kb| kb.size(rems_from_px(10.)))
+                                            })
+                                            .on_click(|_event, _window, cx| {
+                                                cx.defer(|cx| {
+                                                    cx.dispatch_action(&ExpandCommitEditor)
+                                                });
+                                            }),
+                                    ),
+                            ),
+                    )
+                },
+            )
+            .child(
+                v_flex()
+                    .key_context("MessageEditor")
+                    .on_action(cx.listener(Self::chat))
+                    .on_action(cx.listener(|this, _: &ToggleModelSelector, window, cx| {
+                        this.model_selector
+                            .update(cx, |model_selector, cx| model_selector.toggle(window, cx));
+                    }))
+                    .on_action(cx.listener(Self::toggle_context_picker))
+                    .on_action(cx.listener(Self::remove_all_context))
+                    .on_action(cx.listener(Self::move_up))
+                    .on_action(cx.listener(Self::toggle_chat_mode))
+                    .gap_2()
+                    .p_2()
+                    .bg(editor_bg_color)
+                    .border_t_1()
+                    .border_color(cx.theme().colors().border)
+                    .child(h_flex().justify_between().child(self.context_strip.clone()))
+                    .child(
+                        v_flex()
+                            .gap_5()
+                            .child({
+                                let settings = ThemeSettings::get_global(cx);
+                                let text_style = TextStyle {
+                                    color: cx.theme().colors().text,
+                                    font_family: settings.ui_font.family.clone(),
+                                    font_fallbacks: settings.ui_font.fallbacks.clone(),
+                                    font_features: settings.ui_font.features.clone(),
+                                    font_size: font_size.into(),
+                                    font_weight: settings.ui_font.weight,
+                                    line_height: line_height.into(),
+                                    ..Default::default()
+                                };
+
+                                EditorElement::new(
+                                    &self.editor,
+                                    EditorStyle {
+                                        background: editor_bg_color,
+                                        local_player: cx.theme().players().local(),
+                                        text: text_style,
+                                        syntax: cx.theme().syntax().clone(),
+                                        ..Default::default()
+                                    },
+                                )
+                            })
+                            .child(
+                                PopoverMenu::new("inline-context-picker")
+                                    .menu(move |window, cx| {
+                                        inline_context_picker.update(cx, |this, cx| {
+                                            this.init(window, cx);
+                                        });
+
+                                        Some(inline_context_picker.clone())
+                                    })
+                                    .attach(gpui::Corner::TopLeft)
+                                    .anchor(gpui::Corner::BottomLeft)
+                                    .offset(gpui::Point {
+                                        x: px(0.0),
+                                        y: (-ThemeSettings::get_global(cx).ui_font_size(cx) * 2)
+                                            - px(4.0),
+                                    })
+                                    .with_handle(self.inline_context_picker_menu_handle.clone()),
+                            )
+                            .child(
+                                h_flex()
+                                    .justify_between()
+                                    .child(h_flex().gap_2().child(self.profile_selector.clone()))
+                                    .child(
+                                        h_flex().gap_1().child(self.model_selector.clone()).child(
+                                            ButtonLike::new("submit-message")
+                                                .width(button_width.into())
+                                                .style(ButtonStyle::Filled)
+                                                .disabled(
+                                                    is_editor_empty
+                                                        || !is_model_selected
+                                                        || is_generating,
+                                                )
+                                                .child(
+                                                    h_flex()
+                                                        .w_full()
+                                                        .justify_between()
+                                                        .child(
+                                                            Label::new("Submit")
+                                                                .size(LabelSize::Small)
+                                                                .color(submit_label_color),
+                                                        )
+                                                        .children(
+                                                            KeyBinding::for_action_in(
+                                                                &Chat,
+                                                                &focus_handle,
+                                                                window,
+                                                                cx,
+                                                            )
+                                                            .map(|binding| {
+                                                                binding
+                                                                    .when(vim_mode_enabled, |kb| {
+                                                                        kb.size(rems_from_px(12.))
+                                                                    })
+                                                                    .into_any_element()
+                                                            }),
+                                                        ),
+                                                )
+                                                .on_click(move |_event, window, cx| {
+                                                    focus_handle.dispatch_action(&Chat, window, cx);
+                                                })
+                                                .when(is_editor_empty, |button| {
+                                                    button.tooltip(Tooltip::text(
+                                                        "Type a message to submit",
+                                                    ))
+                                                })
+                                                .when(is_generating, |button| {
+                                                    button.tooltip(Tooltip::text(
+                                                        "Cancel to submit a new message",
+                                                    ))
+                                                })
+                                                .when(!is_model_selected, |button| {
+                                                    button.tooltip(Tooltip::text(
+                                                        "Select a model to continue",
+                                                    ))
+                                                }),
+                                        ),
+                                    ),
+                            ),
+                    ),
+            )
+    }
+}

crates/assistant2/src/profile_selector.rs

@@ -0,0 +1,121 @@
+use std::sync::Arc;
+
+use assistant_settings::{AgentProfile, AssistantSettings};
+use fs::Fs;
+use gpui::{prelude::*, Action, Entity, Subscription, WeakEntity};
+use indexmap::IndexMap;
+use settings::{update_settings_file, Settings as _, SettingsStore};
+use ui::{prelude::*, ContextMenu, ContextMenuEntry, PopoverMenu, Tooltip};
+use util::ResultExt as _;
+
+use crate::{ManageProfiles, ThreadStore};
+
+pub struct ProfileSelector {
+    profiles: IndexMap<Arc<str>, AgentProfile>,
+    fs: Arc<dyn Fs>,
+    thread_store: WeakEntity<ThreadStore>,
+    _subscriptions: Vec<Subscription>,
+}
+
+impl ProfileSelector {
+    pub fn new(
+        fs: Arc<dyn Fs>,
+        thread_store: WeakEntity<ThreadStore>,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let settings_subscription = cx.observe_global::<SettingsStore>(move |this, cx| {
+            this.refresh_profiles(cx);
+        });
+
+        let mut this = Self {
+            profiles: IndexMap::default(),
+            fs,
+            thread_store,
+            _subscriptions: vec![settings_subscription],
+        };
+        this.refresh_profiles(cx);
+
+        this
+    }
+
+    fn refresh_profiles(&mut self, cx: &mut Context<Self>) {
+        let settings = AssistantSettings::get_global(cx);
+
+        self.profiles = settings.profiles.clone();
+    }
+
+    fn build_context_menu(
+        &self,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Entity<ContextMenu> {
+        ContextMenu::build(window, cx, |mut menu, _window, cx| {
+            let settings = AssistantSettings::get_global(cx);
+            let icon_position = IconPosition::Start;
+
+            menu = menu.header("Profiles");
+            for (profile_id, profile) in self.profiles.clone() {
+                menu = menu.toggleable_entry(
+                    profile.name.clone(),
+                    profile_id == settings.default_profile,
+                    icon_position,
+                    None,
+                    {
+                        let fs = self.fs.clone();
+                        let thread_store = self.thread_store.clone();
+                        move |_window, cx| {
+                            update_settings_file::<AssistantSettings>(fs.clone(), cx, {
+                                let profile_id = profile_id.clone();
+                                move |settings, _cx| {
+                                    settings.set_profile(profile_id.clone());
+                                }
+                            });
+
+                            thread_store
+                                .update(cx, |this, cx| {
+                                    this.load_profile_by_id(&profile_id, cx);
+                                })
+                                .log_err();
+                        }
+                    },
+                );
+            }
+
+            menu = menu.separator();
+            menu = menu.item(
+                ContextMenuEntry::new("Configure Profiles")
+                    .icon(IconName::Pencil)
+                    .icon_color(Color::Muted)
+                    .handler(move |window, cx| {
+                        window.dispatch_action(ManageProfiles.boxed_clone(), cx);
+                    }),
+            );
+
+            menu
+        })
+    }
+}
+
+impl Render for ProfileSelector {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let settings = AssistantSettings::get_global(cx);
+        let profile = settings
+            .profiles
+            .get(&settings.default_profile)
+            .map(|profile| profile.name.clone())
+            .unwrap_or_else(|| "Unknown".into());
+
+        let this = cx.entity().clone();
+        PopoverMenu::new("tool-selector")
+            .menu(move |window, cx| {
+                Some(this.update(cx, |this, cx| this.build_context_menu(window, cx)))
+            })
+            .trigger_with_tooltip(
+                Button::new("profile-selector-button", profile)
+                    .style(ButtonStyle::Filled)
+                    .label_size(LabelSize::Small),
+                Tooltip::text("Change Profile"),
+            )
+            .anchor(gpui::Corner::BottomLeft)
+    }
+}

crates/assistant2/src/terminal_codegen.rs

@@ -1,10 +1,8 @@
 use crate::inline_prompt_editor::CodegenStatus;
 use client::telemetry::Telemetry;
-use futures::{SinkExt, StreamExt, channel::mpsc};
+use futures::{channel::mpsc, SinkExt, StreamExt};
 use gpui::{App, AppContext as _, Context, Entity, EventEmitter, Task};
-use language_model::{
-    ConfiguredModel, LanguageModelRegistry, LanguageModelRequest, report_assistant_event,
-};
+use language_model::{report_assistant_event, LanguageModelRegistry, LanguageModelRequest};
 use std::{sync::Arc, time::Instant};
 use telemetry_events::{AssistantEvent, AssistantKind, AssistantPhase};
 use terminal::Terminal;
@@ -33,9 +31,7 @@ impl TerminalCodegen {
     }
 
     pub fn start(&mut self, prompt: LanguageModelRequest, cx: &mut Context<Self>) {
-        let Some(ConfiguredModel { model, .. }) =
-            LanguageModelRegistry::read_global(cx).inline_assistant_model()
-        else {
+        let Some(model) = LanguageModelRegistry::read_global(cx).active_model() else {
             return;
         };
 

crates/assistant2/src/terminal_inline_assistant.rs

@@ -3,18 +3,18 @@ use crate::context_store::ContextStore;
 use crate::inline_prompt_editor::{
     CodegenStatus, PromptEditor, PromptEditorEvent, TerminalInlineAssistId,
 };
-use crate::terminal_codegen::{CLEAR_INPUT, CodegenEvent, TerminalCodegen};
+use crate::terminal_codegen::{CodegenEvent, TerminalCodegen, CLEAR_INPUT};
 use crate::thread_store::ThreadStore;
 use anyhow::{Context as _, Result};
 use client::telemetry::Telemetry;
 use collections::{HashMap, VecDeque};
-use editor::{MultiBuffer, actions::SelectAll};
+use editor::{actions::SelectAll, MultiBuffer};
 use fs::Fs;
 use gpui::{App, Entity, Focusable, Global, Subscription, UpdateGlobal, WeakEntity};
 use language::Buffer;
 use language_model::{
-    ConfiguredModel, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage,
-    Role, report_assistant_event,
+    report_assistant_event, LanguageModelRegistry, LanguageModelRequest,
+    LanguageModelRequestMessage, Role,
 };
 use prompt_store::PromptBuilder;
 use std::sync::Arc;
@@ -22,7 +22,7 @@ use telemetry_events::{AssistantEvent, AssistantKind, AssistantPhase};
 use terminal_view::TerminalView;
 use ui::prelude::*;
 use util::ResultExt;
-use workspace::{Toast, Workspace, notifications::NotificationId};
+use workspace::{notifications::NotificationId, Toast, Workspace};
 
 pub fn init(
     fs: Arc<dyn Fs>,
@@ -75,8 +75,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(workspace.clone()));
         let codegen = cx.new(|_| TerminalCodegen::new(terminal, self.telemetry.clone()));
 
         let prompt_editor = cx.new(|cx| {
@@ -253,8 +252,7 @@ impl TerminalInlineAssistant {
 
         attach_context_to_message(
             &mut request_message,
-            assist.context_store.read(cx).context().iter(),
-            cx,
+            assist.context_store.read(cx).snapshot(cx),
         );
 
         request_message.content.push(prompt.into());
@@ -286,9 +284,7 @@ impl TerminalInlineAssistant {
                 })
                 .log_err();
 
-            if let Some(ConfiguredModel { model, .. }) =
-                LanguageModelRegistry::read_global(cx).inline_assistant_model()
-            {
+            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
                 let codegen = assist.codegen.read(cx);
                 let executor = cx.background_executor().clone();
                 report_assistant_event(

crates/assistant2/src/thread_history.rs

@@ -1,176 +1,52 @@
-use std::sync::Arc;
-
 use assistant_context_editor::SavedContextMetadata;
-use editor::{Editor, EditorEvent};
-use fuzzy::{StringMatch, StringMatchCandidate};
 use gpui::{
-    App, Entity, FocusHandle, Focusable, ScrollStrategy, Task, UniformListScrollHandle, WeakEntity,
-    Window, uniform_list,
+    uniform_list, App, Entity, FocusHandle, Focusable, ScrollStrategy, UniformListScrollHandle,
+    WeakEntity,
 };
 use time::{OffsetDateTime, UtcOffset};
-use ui::{HighlightedLabel, IconButtonShape, ListItem, ListItemSpacing, Tooltip, prelude::*};
-use util::ResultExt;
+use ui::{prelude::*, IconButtonShape, ListItem, ListItemSpacing, Tooltip};
 
 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<()>>,
 }
 
 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_in(
-            &search_editor,
-            window,
-            |this, search_editor, event, window, cx| {
-                if let EditorEvent::BufferEdited = event {
-                    let query = search_editor.read(cx).text(cx);
-                    this.search_query = query.into();
-                    this.update_search(window, cx);
-                }
-            },
-        );
-
-        let entries: Arc<Vec<_>> = history_store
-            .update(cx, |store, cx| store.entries(cx))
-            .into();
-
-        let history_store_subscription =
-            cx.observe_in(&history_store, window, |this, history_store, window, cx| {
-                this.all_entries = history_store
-                    .update(cx, |store, cx| store.entries(cx))
-                    .into();
-                this.matches.clear();
-                this.update_search(window, cx);
-            });
-
         Self {
+            focus_handle: cx.focus_handle(),
             assistant_panel,
+            history_store,
             scroll_handle: UniformListScrollHandle::default(),
             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,
-        }
-    }
-
-    fn update_search(&mut self, _window: &mut Window, 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.matched_count();
+        let count = self
+            .history_store
+            .update(cx, |this, cx| this.entry_count(cx));
         if count > 0 {
             if self.selected_index == 0 {
-                self.set_selected_index(count - 1, cx);
+                self.set_selected_index(count - 1, window, cx);
             } else {
-                self.set_selected_index(self.selected_index - 1, cx);
+                self.set_selected_index(self.selected_index - 1, window, cx);
             }
         }
     }
@@ -178,39 +54,40 @@ impl ThreadHistory {
     pub fn select_next(
         &mut self,
         _: &menu::SelectNext,
-        _window: &mut Window,
+        window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        let count = self.matched_count();
+        let count = self
+            .history_store
+            .update(cx, |this, cx| this.entry_count(cx));
         if count > 0 {
             if self.selected_index == count - 1 {
-                self.set_selected_index(0, cx);
+                self.set_selected_index(0, window, cx);
             } else {
-                self.set_selected_index(self.selected_index + 1, cx);
+                self.set_selected_index(self.selected_index + 1, window, cx);
             }
         }
     }
 
-    fn select_first(
-        &mut self,
-        _: &menu::SelectFirst,
-        _window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        let count = self.matched_count();
+    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));
         if count > 0 {
-            self.set_selected_index(0, cx);
+            self.set_selected_index(0, window, cx);
         }
     }
 
-    fn select_last(&mut self, _: &menu::SelectLast, _window: &mut Window, cx: &mut Context<Self>) {
-        let count = self.matched_count();
+    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));
         if count > 0 {
-            self.set_selected_index(count - 1, cx);
+            self.set_selected_index(count - 1, window, cx);
         }
     }
 
-    fn set_selected_index(&mut self, index: usize, cx: &mut Context<Self>) {
+    fn set_selected_index(&mut self, index: usize, _window: &mut Window, cx: &mut Context<Self>) {
         self.selected_index = index;
         self.scroll_handle
             .scroll_to_item(index, ScrollStrategy::Top);
@@ -218,23 +95,23 @@ impl ThreadHistory {
     }
 
     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))
-                    .ok(),
-                HistoryEntry::Context(context) => self
-                    .assistant_panel
-                    .update(cx, move |this, cx| {
-                        this.open_saved_prompt_editor(context.path.clone(), window, cx)
-                    })
-                    .ok(),
-            };
+        let entries = self.history_store.update(cx, |this, cx| this.entries(cx));
 
-            if let Some(task) = task_result {
-                task.detach_and_log_err(cx);
-            };
+        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();
+                }
+                HistoryEntry::Context(context) => {
+                    self.assistant_panel
+                        .update(cx, move |this, cx| {
+                            this.open_saved_prompt_editor(context.path.clone(), window, cx)
+                        })
+                        .ok();
+                }
+            }
 
             cx.notify();
         }
@@ -243,10 +120,12 @@ impl ThreadHistory {
     fn remove_selected_thread(
         &mut self,
         _: &RemoveSelectedThread,
-        window: &mut Window,
+        _window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        if let Some(entry) = self.get_match(self.selected_index) {
+        let entries = self.history_store.update(cx, |this, cx| this.entries(cx));
+
+        if let Some(entry) = entries.get(self.selected_index) {
             match entry {
                 HistoryEntry::Thread(thread) => {
                     self.assistant_panel
@@ -264,117 +143,72 @@ impl ThreadHistory {
                 }
             }
 
-            self.update_search(window, cx);
-
             cx.notify();
         }
     }
 }
 
 impl Focusable for ThreadHistory {
-    fn focus_handle(&self, cx: &App) -> FocusHandle {
-        self.search_editor.focus_handle(cx)
+    fn focus_handle(&self, _cx: &App) -> FocusHandle {
+        self.focus_handle.clone()
     }
 }
 
 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))
-            .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().overflow_hidden().flex_grow();
-
-                if self.all_entries.is_empty() {
-                    view.justify_center()
+            .map(|history| {
+                if history_entries.is_empty() {
+                    history
+                        .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 {
-                    view.p_1().child(
+                    history.child(
                         uniform_list(
                             cx.entity().clone(),
                             "thread-history",
-                            self.matched_count(),
+                            history_entries.len(),
                             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(),
-                                            assistant_panel.clone(),
-                                            selected_index == index + range_start,
-                                            highlight_positions,
-                                        )
-                                        .into_any_element(),
-                                        HistoryEntry::Context(context) => PastContext::new(
-                                            context.clone(),
-                                            assistant_panel.clone(),
-                                            selected_index == index + range_start,
-                                            highlight_positions,
-                                        )
-                                        .into_any_element(),
-                                    })
-                                };
-
-                                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())
-                                            })
+                                history_entries[range]
+                                    .iter()
+                                    .enumerate()
+                                    .map(|(index, entry)| {
+                                        h_flex().w_full().pb_1().child(match entry {
+                                            HistoryEntry::Thread(thread) => PastThread::new(
+                                                thread.clone(),
+                                                history.assistant_panel.clone(),
+                                                selected_index == index,
+                                            )
+                                            .into_any_element(),
+                                            HistoryEntry::Context(context) => PastContext::new(
+                                                context.clone(),
+                                                history.assistant_panel.clone(),
+                                                selected_index == index,
+                                            )
+                                            .into_any_element(),
                                         })
-                                        .collect()
-                                } else {
-                                    history.all_entries[range]
-                                        .iter()
-                                        .enumerate()
-                                        .map(|(index, entry)| render_item(index, entry, vec![]))
-                                        .collect()
-                                }
+                                    })
+                                    .collect()
                             },
                         )
                         .track_scroll(self.scroll_handle.clone())
@@ -390,7 +224,6 @@ pub struct PastThread {
     thread: SerializedThreadMetadata,
     assistant_panel: WeakEntity<AssistantPanel>,
     selected: bool,
-    highlight_positions: Vec<usize>,
 }
 
 impl PastThread {
@@ -398,13 +231,11 @@ impl PastThread {
         thread: SerializedThreadMetadata,
         assistant_panel: WeakEntity<AssistantPanel>,
         selected: bool,
-        highlight_positions: Vec<usize>,
     ) -> Self {
         Self {
             thread,
             assistant_panel,
             selected,
-            highlight_positions,
         }
     }
 }
@@ -427,11 +258,9 @@ impl RenderOnce for PastThread {
             .toggle_state(self.selected)
             .spacing(ListItemSpacing::Sparse)
             .start_slot(
-                div().max_w_4_5().child(
-                    HighlightedLabel::new(summary, self.highlight_positions)
-                        .size(LabelSize::Small)
-                        .truncate(),
-                ),
+                div()
+                    .max_w_4_5()
+                    .child(Label::new(summary).size(LabelSize::Small).truncate()),
             )
             .end_slot(
                 h_flex()
@@ -489,7 +318,6 @@ pub struct PastContext {
     context: SavedContextMetadata,
     assistant_panel: WeakEntity<AssistantPanel>,
     selected: bool,
-    highlight_positions: Vec<usize>,
 }
 
 impl PastContext {
@@ -497,13 +325,11 @@ impl PastContext {
         context: SavedContextMetadata,
         assistant_panel: WeakEntity<AssistantPanel>,
         selected: bool,
-        highlight_positions: Vec<usize>,
     ) -> Self {
         Self {
             context,
             assistant_panel,
             selected,
-            highlight_positions,
         }
     }
 }
@@ -511,6 +337,7 @@ 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(),
@@ -527,11 +354,9 @@ impl RenderOnce for PastContext {
         .toggle_state(self.selected)
         .spacing(ListItemSpacing::Sparse)
         .start_slot(
-            div().max_w_4_5().child(
-                HighlightedLabel::new(summary, self.highlight_positions)
-                    .size(LabelSize::Small)
-                    .truncate(),
-            ),
+            div()
+                .max_w_4_5()
+                .child(Label::new(summary).size(LabelSize::Small).truncate()),
         )
         .end_slot(
             h_flex()

crates/assistant2/src/thread_store.rs

@@ -2,31 +2,28 @@ use std::borrow::Cow;
 use std::path::PathBuf;
 use std::sync::Arc;
 
-use anyhow::{Result, anyhow};
-use assistant_settings::{AgentProfile, AgentProfileId, AssistantSettings};
+use anyhow::{anyhow, Result};
+use assistant_settings::{AgentProfile, 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 futures::FutureExt as _;
 use futures::future::{self, BoxFuture, Shared};
+use futures::FutureExt as _;
 use gpui::{
-    App, BackgroundExecutor, Context, Entity, Global, ReadGlobal, SharedString, Subscription, Task,
-    prelude::*,
+    prelude::*, App, BackgroundExecutor, Context, Entity, Global, ReadGlobal, SharedString, Task,
 };
-use heed::Database;
 use heed::types::SerdeBincode;
+use heed::Database;
 use language_model::{LanguageModelToolUseId, Role, TokenUsage};
 use project::Project;
 use prompt_store::PromptBuilder;
 use serde::{Deserialize, Serialize};
-use settings::{Settings as _, SettingsStore};
+use settings::Settings as _;
 use util::ResultExt as _;
 
-use crate::thread::{
-    DetailedSummaryState, MessageId, ProjectSnapshot, Thread, ThreadEvent, ThreadId,
-};
+use crate::thread::{MessageId, ProjectSnapshot, Thread, ThreadEvent, ThreadId};
 
 pub fn init(cx: &mut App) {
     ThreadsDatabase::init(cx);
@@ -39,7 +36,6 @@ pub struct ThreadStore {
     context_server_manager: Entity<ContextServerManager>,
     context_server_tool_ids: HashMap<Arc<str>, Vec<ToolId>>,
     threads: Vec<SerializedThreadMetadata>,
-    _subscriptions: Vec<Subscription>,
 }
 
 impl ThreadStore {
@@ -54,10 +50,6 @@ impl ThreadStore {
             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 this = Self {
                 project,
@@ -66,7 +58,6 @@ impl ThreadStore {
                 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);
@@ -202,15 +193,15 @@ impl ThreadStore {
         self.load_profile_by_id(&assistant_settings.default_profile, cx);
     }
 
-    pub fn load_profile_by_id(&self, profile_id: &AgentProfileId, cx: &Context<Self>) {
+    pub fn load_profile_by_id(&self, profile_id: &Arc<str>, cx: &Context<Self>) {
         let assistant_settings = AssistantSettings::get_global(cx);
 
         if let Some(profile) = assistant_settings.profiles.get(profile_id) {
-            self.load_profile(profile, cx);
+            self.load_profile(profile);
         }
     }
 
-    pub fn load_profile(&self, profile: &AgentProfile, cx: &Context<Self>) {
+    pub fn load_profile(&self, profile: &AgentProfile) {
         self.tools.disable_all_tools();
         self.tools.enable(
             ToolSource::Native,
@@ -221,28 +212,17 @@ impl ThreadStore {
                 .collect::<Vec<_>>(),
         );
 
-        if profile.enable_all_context_servers {
-            for context_server in self.context_server_manager.read(cx).all_servers() {
-                self.tools.enable_source(
-                    ToolSource::ContextServer {
-                        id: context_server.id().into(),
-                    },
-                    cx,
-                );
-            }
-        } else {
-            for (context_server_id, preset) in &profile.context_servers {
-                self.tools.enable(
-                    ToolSource::ContextServer {
-                        id: context_server_id.clone().into(),
-                    },
-                    &preset
-                        .tools
-                        .iter()
-                        .filter_map(|(tool, enabled)| enabled.then(|| tool.clone()))
-                        .collect::<Vec<_>>(),
-                )
-            }
+        for (context_server_id, preset) in &profile.context_servers {
+            self.tools.enable(
+                ToolSource::ContextServer {
+                    id: context_server_id.clone().into(),
+                },
+                &preset
+                    .tools
+                    .iter()
+                    .filter_map(|(tool, enabled)| enabled.then(|| tool.clone()))
+                    .collect::<Vec<_>>(),
+            )
         }
     }
 
@@ -293,9 +273,8 @@ impl ThreadStore {
                                         })
                                         .collect::<Vec<_>>();
 
-                                    this.update(cx, |this, cx| {
+                                    this.update(cx, |this, _cx| {
                                         this.context_server_tool_ids.insert(server_id, tool_ids);
-                                        this.load_default_profile(cx);
                                     })
                                     .log_err();
                                 }
@@ -308,7 +287,6 @@ impl ThreadStore {
             context_server::manager::Event::ServerStopped { server_id } => {
                 if let Some(tool_ids) = self.context_server_tool_ids.remove(server_id) {
                     tool_working_set.remove(&tool_ids);
-                    self.load_default_profile(cx);
                 }
             }
         }
@@ -322,7 +300,7 @@ pub struct SerializedThreadMetadata {
     pub updated_at: DateTime<Utc>,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize)]
 pub struct SerializedThread {
     pub version: String,
     pub summary: SharedString,
@@ -332,8 +310,6 @@ pub struct SerializedThread {
     pub initial_project_snapshot: Option<Arc<ProjectSnapshot>>,
     #[serde(default)]
     pub cumulative_token_usage: TokenUsage,
-    #[serde(default)]
-    pub detailed_summary_state: DetailedSummaryState,
 }
 
 impl SerializedThread {
@@ -374,8 +350,6 @@ pub struct SerializedMessage {
     pub tool_uses: Vec<SerializedToolUse>,
     #[serde(default)]
     pub tool_results: Vec<SerializedToolResult>,
-    #[serde(default)]
-    pub context: String,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -419,7 +393,6 @@ impl LegacySerializedThread {
             messages: self.messages.into_iter().map(|msg| msg.upgrade()).collect(),
             initial_project_snapshot: self.initial_project_snapshot,
             cumulative_token_usage: TokenUsage::default(),
-            detailed_summary_state: DetailedSummaryState::default(),
         }
     }
 }
@@ -443,7 +416,6 @@ impl LegacySerializedMessage {
             segments: vec![SerializedMessageSegment::Text { text: self.text }],
             tool_uses: self.tool_uses,
             tool_results: self.tool_results,
-            context: String::new(),
         }
     }
 }

crates/assistant2/src/tool_use.rs

@@ -3,8 +3,8 @@ use std::sync::Arc;
 use anyhow::Result;
 use assistant_tool::{Tool, ToolWorkingSet};
 use collections::HashMap;
-use futures::FutureExt as _;
 use futures::future::Shared;
+use futures::FutureExt as _;
 use gpui::{App, SharedString, Task};
 use language_model::{
     LanguageModelRequestMessage, LanguageModelToolResult, LanguageModelToolUse,
@@ -23,7 +23,6 @@ pub struct ToolUse {
     pub status: ToolUseStatus,
     pub input: serde_json::Value,
     pub icon: ui::IconName,
-    pub needs_confirmation: bool,
 }
 
 #[derive(Debug, Clone)]
@@ -43,8 +42,6 @@ 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 {
@@ -115,7 +112,6 @@ impl ToolUseState {
                                 tool_use_id.clone(),
                                 LanguageModelToolResult {
                                     tool_use_id,
-                                    tool_name: tool_use.clone(),
                                     is_error: tool_result.is_error,
                                     content: tool_result.content.clone(),
                                 },
@@ -137,7 +133,6 @@ impl ToolUseState {
                 tool_use_id.clone(),
                 LanguageModelToolResult {
                     tool_use_id,
-                    tool_name: tool_use.name.clone(),
                     content: "Tool canceled by user".into(),
                     is_error: true,
                 },
@@ -186,11 +181,10 @@ impl ToolUseState {
                 }
             })();
 
-            let (icon, needs_confirmation) = if let Some(tool) = self.tools.tool(&tool_use.name, cx)
-            {
-                (tool.icon(), tool.needs_confirmation())
+            let icon = if let Some(tool) = self.tools.tool(&tool_use.name, cx) {
+                tool.icon()
             } else {
-                (IconName::Cog, false)
+                IconName::Cog
             };
 
             tool_uses.push(ToolUse {
@@ -200,7 +194,6 @@ impl ToolUseState {
                 input: tool_use.input.clone(),
                 status,
                 icon,
-                needs_confirmation,
             })
         }
 
@@ -216,7 +209,7 @@ impl ToolUseState {
         if let Some(tool) = self.tools.tool(tool_name, cx) {
             tool.ui_text(input).into()
         } else {
-            format!("Unknown tool {tool_name:?}").into()
+            "Unknown tool".into()
         }
     }
 
@@ -317,7 +310,6 @@ impl ToolUseState {
     pub fn insert_tool_output(
         &mut self,
         tool_use_id: LanguageModelToolUseId,
-        tool_name: Arc<str>,
         output: Result<String>,
     ) -> Option<PendingToolUse> {
         match output {
@@ -326,7 +318,6 @@ impl ToolUseState {
                     tool_use_id.clone(),
                     LanguageModelToolResult {
                         tool_use_id: tool_use_id.clone(),
-                        tool_name,
                         content: tool_result.into(),
                         is_error: false,
                     },
@@ -338,7 +329,6 @@ impl ToolUseState {
                     tool_use_id.clone(),
                     LanguageModelToolResult {
                         tool_use_id: tool_use_id.clone(),
-                        tool_name,
                         content: err.to_string().into(),
                         is_error: true,
                     },
@@ -359,28 +349,8 @@ 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
@@ -406,7 +376,6 @@ impl ToolUseState {
                     request_message.content.push(MessageContent::ToolResult(
                         LanguageModelToolResult {
                             tool_use_id: tool_use_id.clone(),
-                            tool_name: tool_result.tool_name.clone(),
                             is_error: tool_result.is_error,
                             content: if tool_result.content.is_empty() {
                                 // Surprisingly, the API fails if we return an empty string here.

crates/assistant2/src/ui.rs

@@ -0,0 +1,5 @@
+mod context_pill;
+mod tool_ready_pop_up;
+
+pub use context_pill::*;
+pub use tool_ready_pop_up::*;

crates/assistant2/src/ui/context_pill.rs

@@ -1,16 +1,14 @@
-use std::{rc::Rc, time::Duration};
+use std::rc::Rc;
 
-use file_icons::FileIcons;
 use gpui::ClickEvent;
-use gpui::{Animation, AnimationExt as _, pulsating_between};
-use ui::{IconButtonShape, Tooltip, prelude::*};
+use ui::{prelude::*, IconButtonShape, Tooltip};
 
-use crate::context::{AssistantContext, ContextId, ContextKind};
+use crate::context::{ContextKind, ContextSnapshot};
 
 #[derive(IntoElement)]
 pub enum ContextPill {
     Added {
-        context: AddedContext,
+        context: ContextSnapshot,
         dupe_name: bool,
         focused: bool,
         on_click: Option<Rc<dyn Fn(&ClickEvent, &mut Window, &mut App)>>,
@@ -27,7 +25,7 @@ pub enum ContextPill {
 
 impl ContextPill {
     pub fn added(
-        context: AddedContext,
+        context: ContextSnapshot,
         dupe_name: bool,
         focused: bool,
         on_remove: Option<Rc<dyn Fn(&ClickEvent, &mut Window, &mut App)>>,
@@ -79,21 +77,17 @@ impl ContextPill {
 
     pub fn icon(&self) -> Icon {
         match self {
+            Self::Added { context, .. } => match &context.icon_path {
+                Some(icon_path) => Icon::from_path(icon_path),
+                None => Icon::new(context.kind.icon()),
+            },
             Self::Suggested {
                 icon_path: Some(icon_path),
                 ..
-            }
-            | Self::Added {
-                context:
-                    AddedContext {
-                        icon_path: Some(icon_path),
-                        ..
-                    },
-                ..
             } => Icon::from_path(icon_path),
-            Self::Suggested { kind, .. }
-            | Self::Added {
-                context: AddedContext { kind, .. },
+            Self::Suggested {
+                kind,
+                icon_path: None,
                 ..
             } => Icon::new(kind.icon()),
         }
@@ -150,7 +144,7 @@ impl RenderOnce for ContextPill {
                                 element
                             }
                         })
-                        .when_some(context.tooltip.as_ref(), |element, tooltip| {
+                        .when_some(context.tooltip.clone(), |element, tooltip| {
                             element.tooltip(Tooltip::text(tooltip.clone()))
                         }),
                 )
@@ -168,25 +162,7 @@ impl RenderOnce for ContextPill {
                 })
                 .when_some(on_click.as_ref(), |element, on_click| {
                     let on_click = on_click.clone();
-                    element
-                        .cursor_pointer()
-                        .on_click(move |event, window, cx| on_click(event, window, cx))
-                })
-                .map(|element| {
-                    if context.summarizing {
-                        element
-                            .tooltip(ui::Tooltip::text("Summarizing..."))
-                            .with_animation(
-                                "pulsating-ctx-pill",
-                                Animation::new(Duration::from_secs(2))
-                                    .repeat()
-                                    .with_easing(pulsating_between(0.4, 0.8)),
-                                |label, delta| label.opacity(delta),
-                            )
-                            .into_any_element()
-                    } else {
-                        element.into_any()
-                    }
+                    element.on_click(move |event, window, cx| on_click(event, window, cx))
                 }),
             ContextPill::Suggested {
                 name,
@@ -197,14 +173,10 @@ impl RenderOnce for ContextPill {
             } => base_pill
                 .cursor_pointer()
                 .pr_1()
-                .when(*focused, |this| {
-                    this.bg(color.element_background.opacity(0.5))
-                })
-                .border_dashed()
                 .border_color(if *focused {
                     color.border_focused
                 } else {
-                    color.border
+                    color.border_variant.opacity(0.5)
                 })
                 .hover(|style| style.bg(color.element_hover.opacity(0.5)))
                 .child(
@@ -218,10 +190,9 @@ impl RenderOnce for ContextPill {
                 .child(
                     Label::new(match kind {
                         ContextKind::File => "Active Tab",
-                        ContextKind::Thread
-                        | ContextKind::Directory
-                        | ContextKind::FetchedUrl
-                        | ContextKind::Symbol => "Active",
+                        ContextKind::Thread | ContextKind::Directory | ContextKind::FetchedUrl => {
+                            "Active"
+                        }
                     })
                     .size(LabelSize::XSmall)
                     .color(Color::Muted),
@@ -237,105 +208,7 @@ impl RenderOnce for ContextPill {
                 .when_some(on_click.as_ref(), |element, on_click| {
                     let on_click = on_click.clone();
                     element.on_click(move |event, window, cx| on_click(event, window, cx))
-                })
-                .into_any(),
-        }
-    }
-}
-
-pub struct AddedContext {
-    pub id: ContextId,
-    pub kind: ContextKind,
-    pub name: SharedString,
-    pub parent: Option<SharedString>,
-    pub tooltip: Option<SharedString>,
-    pub icon_path: Option<SharedString>,
-    pub summarizing: bool,
-}
-
-impl AddedContext {
-    pub fn new(context: &AssistantContext, cx: &App) -> AddedContext {
-        match context {
-            AssistantContext::File(file_context) => {
-                let full_path = file_context.context_buffer.file.full_path(cx);
-                let full_path_string: SharedString =
-                    full_path.to_string_lossy().into_owned().into();
-                let name = full_path
-                    .file_name()
-                    .map(|n| n.to_string_lossy().into_owned().into())
-                    .unwrap_or_else(|| full_path_string.clone());
-                let parent = full_path
-                    .parent()
-                    .and_then(|p| p.file_name())
-                    .map(|n| n.to_string_lossy().into_owned().into());
-                AddedContext {
-                    id: file_context.id,
-                    kind: ContextKind::File,
-                    name,
-                    parent,
-                    tooltip: Some(full_path_string),
-                    icon_path: FileIcons::get_icon(&full_path, cx),
-                    summarizing: false,
-                }
-            }
-
-            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_string: SharedString =
-                    full_path.to_string_lossy().into_owned().into();
-                let name = full_path
-                    .file_name()
-                    .map(|n| n.to_string_lossy().into_owned().into())
-                    .unwrap_or_else(|| full_path_string.clone());
-                let parent = full_path
-                    .parent()
-                    .and_then(|p| p.file_name())
-                    .map(|n| n.to_string_lossy().into_owned().into());
-                AddedContext {
-                    id: directory_context.id,
-                    kind: ContextKind::Directory,
-                    name,
-                    parent,
-                    tooltip: Some(full_path_string),
-                    icon_path: None,
-                    summarizing: false,
-                }
-            }
-
-            AssistantContext::Symbol(symbol_context) => AddedContext {
-                id: symbol_context.id,
-                kind: ContextKind::Symbol,
-                name: symbol_context.context_symbol.id.name.clone(),
-                parent: None,
-                tooltip: None,
-                icon_path: None,
-                summarizing: false,
-            },
-
-            AssistantContext::FetchedUrl(fetched_url_context) => AddedContext {
-                id: fetched_url_context.id,
-                kind: ContextKind::FetchedUrl,
-                name: fetched_url_context.url.clone(),
-                parent: None,
-                tooltip: None,
-                icon_path: None,
-                summarizing: false,
-            },
-
-            AssistantContext::Thread(thread_context) => AddedContext {
-                id: thread_context.id,
-                kind: ContextKind::Thread,
-                name: thread_context.summary(cx),
-                parent: None,
-                tooltip: None,
-                icon_path: None,
-                summarizing: thread_context
-                    .thread
-                    .read(cx)
-                    .is_generating_detailed_summary(),
-            },
+                }),
         }
     }
 }

crates/assistant2/src/ui/tool_ready_pop_up.rs

@@ -1,29 +1,24 @@
 use gpui::{
-    App, Context, EventEmitter, IntoElement, PlatformDisplay, Size, Window,
+    point, App, Context, EventEmitter, IntoElement, PlatformDisplay, Size, Window,
     WindowBackgroundAppearance, WindowBounds, WindowDecorations, WindowKind, WindowOptions,
-    linear_color_stop, linear_gradient, point,
 };
 use release_channel::ReleaseChannel;
 use std::rc::Rc;
 use theme;
-use ui::{Render, prelude::*};
+use ui::{prelude::*, Render};
 
-pub struct AgentNotification {
-    title: SharedString,
+pub struct ToolReadyPopUp {
     caption: SharedString,
     icon: IconName,
+    icon_color: Color,
 }
 
-impl AgentNotification {
-    pub fn new(
-        title: impl Into<SharedString>,
-        caption: impl Into<SharedString>,
-        icon: IconName,
-    ) -> Self {
+impl ToolReadyPopUp {
+    pub fn new(caption: impl Into<SharedString>, icon: IconName, icon_color: Color) -> Self {
         Self {
-            title: title.into(),
             caption: caption.into(),
             icon,
+            icon_color,
         }
     }
 
@@ -63,35 +58,19 @@ impl AgentNotification {
     }
 }
 
-pub enum AgentNotificationEvent {
+pub enum ToolReadyPopupEvent {
     Accepted,
     Dismissed,
 }
 
-impl EventEmitter<AgentNotificationEvent> for AgentNotification {}
+impl EventEmitter<ToolReadyPopupEvent> for ToolReadyPopUp {}
 
-impl Render for AgentNotification {
+impl Render for ToolReadyPopUp {
     fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
         let ui_font = theme::setup_ui_font(window, cx);
         let line_height = window.line_height();
 
-        let bg = cx.theme().colors().elevated_surface_background;
-        let gradient_overflow = || {
-            div()
-                .h_full()
-                .absolute()
-                .w_8()
-                .bottom_0()
-                .right_0()
-                .bg(linear_gradient(
-                    90.,
-                    linear_color_stop(bg, 1.),
-                    linear_color_stop(bg.opacity(0.2), 0.),
-                ))
-        };
-
         h_flex()
-            .id("agent-notification")
             .size_full()
             .p_3()
             .gap_4()
@@ -101,62 +80,48 @@ impl Render for AgentNotification {
             .font(ui_font)
             .border_color(cx.theme().colors().border)
             .rounded_xl()
-            .on_click(cx.listener(|_, _, _, cx| {
-                cx.emit(AgentNotificationEvent::Accepted);
-            }))
             .child(
                 h_flex()
                     .items_start()
                     .gap_2()
-                    .flex_1()
                     .child(
                         h_flex().h(line_height).justify_center().child(
                             Icon::new(self.icon)
-                                .color(Color::Muted)
+                                .color(self.icon_color)
                                 .size(IconSize::Small),
                         ),
                     )
                     .child(
                         v_flex()
-                            .flex_1()
-                            .max_w(px(300.))
                             .child(
                                 div()
-                                    .relative()
-                                    .text_size(px(14.))
+                                    .text_size(px(16.))
                                     .text_color(cx.theme().colors().text)
-                                    .truncate()
-                                    .child(self.title.clone())
-                                    .child(gradient_overflow()),
+                                    .child("Agent Panel"),
                             )
                             .child(
                                 div()
-                                    .relative()
-                                    .text_size(px(12.))
+                                    .text_size(px(14.))
                                     .text_color(cx.theme().colors().text_muted)
-                                    .truncate()
-                                    .child(self.caption.clone())
-                                    .child(gradient_overflow()),
+                                    .child(self.caption.clone()),
                             ),
                     ),
             )
             .child(
-                v_flex()
-                    .gap_1()
-                    .items_center()
+                h_flex()
+                    .gap_0p5()
                     .child(
                         Button::new("open", "View Panel")
                             .style(ButtonStyle::Tinted(ui::TintColor::Accent))
-                            .full_width()
                             .on_click({
                                 cx.listener(move |_this, _event, _, cx| {
-                                    cx.emit(AgentNotificationEvent::Accepted);
+                                    cx.emit(ToolReadyPopupEvent::Accepted);
                                 })
                             }),
                     )
-                    .child(Button::new("dismiss", "Dismiss").full_width().on_click({
+                    .child(Button::new("dismiss", "Dismiss").on_click({
                         cx.listener(move |_, _event, _, cx| {
-                            cx.emit(AgentNotificationEvent::Dismissed);
+                            cx.emit(ToolReadyPopupEvent::Dismissed);
                         })
                     })),
             )

crates/assistant_context_editor/Cargo.toml

@@ -54,7 +54,6 @@ ui.workspace = true
 util.workspace = true
 uuid.workspace = true
 workspace.workspace = true
-workspace-hack.workspace = true
 
 [dev-dependencies]
 language_model = { workspace = true, features = ["test-support"] }

crates/assistant_context_editor/src/context.rs

@@ -2,7 +2,7 @@
 mod context_tests;
 
 use crate::patch::{AssistantEdit, AssistantPatch, AssistantPatchStatus};
-use anyhow::{Context as _, Result, anyhow};
+use anyhow::{anyhow, Context as _, Result};
 use assistant_slash_command::{
     SlashCommandContent, SlashCommandEvent, SlashCommandLine, SlashCommandOutputSection,
     SlashCommandResult, SlashCommandWorkingSet,
@@ -12,17 +12,17 @@ use client::{self, proto, telemetry::Telemetry};
 use clock::ReplicaId;
 use collections::{HashMap, HashSet};
 use fs::{Fs, RemoveOptions};
-use futures::{FutureExt, StreamExt, future::Shared};
+use futures::{future::Shared, FutureExt, StreamExt};
 use gpui::{
     App, AppContext as _, Context, Entity, EventEmitter, RenderImage, SharedString, Subscription,
     Task,
 };
 use language::{AnchorRangeExt, Bias, Buffer, LanguageRegistry, OffsetRangeExt, Point, ToOffset};
 use language_model::{
-    LanguageModel, LanguageModelCacheConfiguration, LanguageModelCompletionEvent,
-    LanguageModelImage, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage,
-    LanguageModelToolUseId, MaxMonthlySpendReachedError, MessageContent, PaymentRequiredError,
-    Role, StopReason, report_assistant_event,
+    report_assistant_event, LanguageModel, LanguageModelCacheConfiguration,
+    LanguageModelCompletionEvent, LanguageModelImage, LanguageModelRegistry, LanguageModelRequest,
+    LanguageModelRequestMessage, LanguageModelToolUseId, MaxMonthlySpendReachedError,
+    MessageContent, PaymentRequiredError, Role, StopReason,
 };
 use open_ai::Model as OpenAiModel;
 use paths::contexts_dir;
@@ -31,7 +31,7 @@ use prompt_store::PromptBuilder;
 use serde::{Deserialize, Serialize};
 use smallvec::SmallVec;
 use std::{
-    cmp::{Ordering, max},
+    cmp::{max, Ordering},
     fmt::Debug,
     iter, mem,
     ops::Range,
@@ -43,7 +43,7 @@ use std::{
 use telemetry_events::{AssistantEvent, AssistantKind, AssistantPhase};
 use text::{BufferSnapshot, ToPoint};
 use ui::IconName;
-use util::{ResultExt, TryFutureExt, post_inc};
+use util::{post_inc, ResultExt, TryFutureExt};
 use uuid::Uuid;
 
 #[derive(Clone, Eq, PartialEq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
@@ -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).default_model() else {
+        let Some(model) = LanguageModelRegistry::read_global(cx).active_model() else {
             return;
         };
         let debounce = self.token_count.is_some();
@@ -1284,12 +1284,10 @@ impl AssistantContext {
                         .await;
                 }
 
-                let token_count = cx
-                    .update(|cx| model.model.count_tokens(request, cx))?
-                    .await?;
+                let token_count = cx.update(|cx| model.count_tokens(request, cx))?.await?;
                 this.update(cx, |this, cx| {
                     this.token_count = Some(token_count);
-                    this.start_cache_warming(&model.model, cx);
+                    this.start_cache_warming(&model, cx);
                     cx.notify()
                 })
             }
@@ -2306,16 +2304,14 @@ impl AssistantContext {
         cx: &mut Context<Self>,
     ) -> Option<MessageAnchor> {
         let model_registry = LanguageModelRegistry::read_global(cx);
-        let model = model_registry.default_model()?;
+        let provider = model_registry.active_provider()?;
+        let model = model_registry.active_model()?;
         let last_message_id = self.get_last_valid_message_id(cx)?;
 
-        if !model.provider.is_authenticated(cx) {
+        if !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);
 
@@ -2944,12 +2940,15 @@ impl AssistantContext {
     }
 
     pub fn summarize(&mut self, replace_old: bool, cx: &mut Context<Self>) {
-        let Some(model) = LanguageModelRegistry::read_global(cx).default_model() else {
+        let Some(provider) = LanguageModelRegistry::read_global(cx).active_provider() else {
+            return;
+        };
+        let Some(model) = LanguageModelRegistry::read_global(cx).active_model() else {
             return;
         };
 
         if replace_old || (self.message_anchors.len() >= 2 && self.summary.is_none()) {
-            if !model.provider.is_authenticated(cx) {
+            if !provider.is_authenticated(cx) {
                 return;
             }
 
@@ -2965,7 +2964,7 @@ impl AssistantContext {
 
             self.pending_summary = cx.spawn(async move |this, cx| {
                 async move {
-                    let stream = model.model.stream_completion_text(request, &cx);
+                    let stream = model.stream_completion_text(request, &cx);
                     let mut messages = stream.await?;
 
                     let mut replaced = !replace_old;

crates/assistant_context_editor/src/context/context_tests.rs

@@ -14,7 +14,7 @@ use futures::{
     channel::mpsc,
     stream::{self, StreamExt},
 };
-use gpui::{App, Entity, SharedString, Task, TestAppContext, WeakEntity, prelude::*};
+use gpui::{prelude::*, App, Entity, SharedString, Task, TestAppContext, WeakEntity};
 use language::{Buffer, BufferSnapshot, LanguageRegistry, LspAdapterDelegate};
 use language_model::{LanguageModelCacheConfiguration, LanguageModelRegistry, Role};
 use parking_lot::Mutex;
@@ -30,14 +30,14 @@ use std::{
     ops::Range,
     path::Path,
     rc::Rc,
-    sync::{Arc, atomic::AtomicBool},
+    sync::{atomic::AtomicBool, Arc},
 };
-use text::{OffsetRangeExt as _, ReplicaId, ToOffset, network::Network};
+use text::{network::Network, OffsetRangeExt as _, ReplicaId, ToOffset};
 use ui::{IconName, Window};
 use unindent::Unindent;
 use util::{
-    RandomCharIter,
     test::{generate_marked_text, marked_text_ranges},
+    RandomCharIter,
 };
 use workspace::Workspace;
 

crates/assistant_context_editor/src/context_editor.rs

@@ -2,36 +2,36 @@ use anyhow::Result;
 use assistant_settings::AssistantSettings;
 use assistant_slash_command::{SlashCommand, SlashCommandOutputSection, SlashCommandWorkingSet};
 use assistant_slash_commands::{
-    DefaultSlashCommand, DocsSlashCommand, DocsSlashCommandArgs, FileSlashCommand,
-    selections_creases,
+    selections_creases, DefaultSlashCommand, DocsSlashCommand, DocsSlashCommandArgs,
+    FileSlashCommand,
 };
 use client::{proto, zed_urls};
-use collections::{BTreeSet, HashMap, HashSet, hash_map};
+use collections::{hash_map, BTreeSet, HashMap, HashSet};
 use editor::{
-    Anchor, Editor, EditorEvent, MenuInlineCompletionsPolicy, ProposedChangeLocation,
-    ProposedChangesEditor, RowExt, ToOffset as _, ToPoint,
     actions::{FoldAt, MoveToEndOfLine, Newline, ShowCompletions, UnfoldAt},
     display_map::{
         BlockContext, BlockId, BlockPlacement, BlockProperties, BlockStyle, Crease, CreaseMetadata,
         CustomBlockId, FoldId, RenderBlock, ToDisplayPoint,
     },
     scroll::Autoscroll,
+    Anchor, Editor, EditorEvent, MenuInlineCompletionsPolicy, ProposedChangeLocation,
+    ProposedChangesEditor, RowExt, ToOffset as _, ToPoint,
 };
-use editor::{FoldPlaceholder, display_map::CreaseId};
+use editor::{display_map::CreaseId, FoldPlaceholder};
 use fs::Fs;
 use futures::FutureExt;
 use gpui::{
-    Animation, AnimationExt, AnyElement, AnyView, App, AsyncWindowContext, ClipboardEntry,
+    actions, div, img, impl_internal_actions, percentage, point, prelude::*, pulsating_between,
+    size, Animation, AnimationExt, AnyElement, AnyView, App, AsyncWindowContext, ClipboardEntry,
     ClipboardItem, CursorStyle, Empty, Entity, EventEmitter, FocusHandle, Focusable, FontWeight,
     Global, InteractiveElement, IntoElement, ParentElement, Pixels, Render, RenderImage,
     SharedString, Size, StatefulInteractiveElement, Styled, Subscription, Task, Transformation,
-    WeakEntity, actions, div, img, impl_internal_actions, percentage, point, prelude::*,
-    pulsating_between, size,
+    WeakEntity,
 };
 use indexed_docs::IndexedDocsStore;
 use language::{
+    language_settings::{all_language_settings, SoftWrap},
     BufferSnapshot, LspAdapterDelegate, ToOffset,
-    language_settings::{SoftWrap, all_language_settings},
 };
 use language_model::{
     LanguageModelImage, LanguageModelProvider, LanguageModelProviderTosView, LanguageModelRegistry,
@@ -46,33 +46,33 @@ use project::lsp_store::LocalLspAdapterDelegate;
 use project::{Project, Worktree};
 use rope::Point;
 use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsStore, update_settings_file};
+use settings::{update_settings_file, Settings, SettingsStore};
 use std::{any::TypeId, borrow::Cow, cmp, ops::Range, path::PathBuf, sync::Arc, time::Duration};
 use text::SelectionGoal;
 use ui::{
-    ButtonLike, Disclosure, ElevationIndex, KeyBinding, PopoverMenuHandle, TintColor, Tooltip,
-    prelude::*,
+    prelude::*, ButtonLike, Disclosure, ElevationIndex, KeyBinding, PopoverMenuHandle, TintColor,
+    Tooltip,
 };
-use util::{ResultExt, maybe};
+use util::{maybe, ResultExt};
 use workspace::searchable::{Direction, SearchableItemHandle};
 use workspace::{
-    Save, ShowConfiguration, Toast, ToolbarItemEvent, ToolbarItemLocation, ToolbarItemView,
-    Workspace,
     item::{self, FollowableItem, Item, ItemHandle},
     notifications::NotificationId,
     pane::{self, SaveIntent},
     searchable::{SearchEvent, SearchableItem},
+    Save, ShowConfiguration, Toast, ToolbarItemEvent, ToolbarItemLocation, ToolbarItemView,
+    Workspace,
 };
 
+use crate::{
+    slash_command::SlashCommandCompletionProvider, slash_command_picker,
+    ThoughtProcessOutputSection,
+};
 use crate::{
     AssistantContext, AssistantPatch, AssistantPatchStatus, CacheStatus, Content, ContextEvent,
     ContextId, InvokedSlashCommandId, InvokedSlashCommandStatus, Message, MessageId,
     MessageMetadata, MessageStatus, ParsedSlashCommand, PendingSlashCommandStatus, RequestType,
 };
-use crate::{
-    ThoughtProcessOutputSection, slash_command::SlashCommandCompletionProvider,
-    slash_command_picker,
-};
 
 actions!(
     assistant,
@@ -384,9 +384,7 @@ impl ContextEditor {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        let provider = LanguageModelRegistry::read_global(cx)
-            .default_model()
-            .map(|default| default.provider);
+        let provider = LanguageModelRegistry::read_global(cx).active_provider();
         if provider
             .as_ref()
             .map_or(false, |provider| provider.must_accept_terms(cx))
@@ -2397,13 +2395,13 @@ impl ContextEditor {
             None => (ButtonStyle::Filled, None),
         };
 
-        let model = LanguageModelRegistry::read_global(cx).default_model();
+        let provider = LanguageModelRegistry::read_global(cx).active_provider();
 
         let has_configuration_error = configuration_error(cx).is_some();
         let needs_to_accept_terms = self.show_accept_terms
-            && model
+            && provider
                 .as_ref()
-                .map_or(false, |model| model.provider.must_accept_terms(cx));
+                .map_or(false, |provider| provider.must_accept_terms(cx));
         let disabled = has_configuration_error || needs_to_accept_terms;
 
         ButtonLike::new("send_button")
@@ -2456,9 +2454,7 @@ impl ContextEditor {
             None => (ButtonStyle::Filled, None),
         };
 
-        let provider = LanguageModelRegistry::read_global(cx)
-            .default_model()
-            .map(|default| default.provider);
+        let provider = LanguageModelRegistry::read_global(cx).active_provider();
 
         let has_configuration_error = configuration_error(cx).is_some();
         let needs_to_accept_terms = self.show_accept_terms
@@ -2504,9 +2500,7 @@ impl ContextEditor {
     }
 
     fn render_language_model_selector(&self, cx: &mut Context<Self>) -> impl IntoElement {
-        let active_model = LanguageModelRegistry::read_global(cx)
-            .default_model()
-            .map(|default| default.model);
+        let active_model = LanguageModelRegistry::read_global(cx).active_model();
         let focus_handle = self.editor().focus_handle(cx).clone();
         let model_name = match active_model {
             Some(model) => model.name().0,
@@ -3026,9 +3020,7 @@ 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)
-            .default_model()
-            .map(|default| default.provider);
+        let provider = LanguageModelRegistry::read_global(cx).active_provider();
         let accept_terms = if self.show_accept_terms {
             provider.as_ref().and_then(|provider| {
                 provider.render_accept_terms(LanguageModelProviderTosView::PromptEditorPopup, cx)
@@ -3421,7 +3413,7 @@ impl ContextEditorToolbarItem {
 pub fn render_remaining_tokens(
     context_editor: &Entity<ContextEditor>,
     cx: &App,
-) -> Option<impl IntoElement + use<>> {
+) -> Option<impl IntoElement> {
     let context = &context_editor.read(cx).context;
 
     let (token_count_color, token_count, max_token_count, tooltip) = match token_state(context, cx)?
@@ -3624,9 +3616,7 @@ 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)
-        .default_model()?
-        .model;
+    let model = LanguageModelRegistry::read_global(cx).active_model()?;
     let token_count = context.read(cx).token_count()?;
     let max_token_count = model.max_token_count();
 
@@ -3679,16 +3669,16 @@ pub enum ConfigurationError {
 }
 
 fn configuration_error(cx: &App) -> Option<ConfigurationError> {
-    let model = LanguageModelRegistry::read_global(cx).default_model();
-    let is_authenticated = model
+    let provider = LanguageModelRegistry::read_global(cx).active_provider();
+    let is_authenticated = provider
         .as_ref()
-        .map_or(false, |model| model.provider.is_authenticated(cx));
+        .map_or(false, |provider| provider.is_authenticated(cx));
 
-    if model.is_some() && is_authenticated {
+    if provider.is_some() && is_authenticated {
         return None;
     }
 
-    if model.is_none() {
+    if provider.is_none() {
         return Some(ConfigurationError::NoProvider);
     }
 
@@ -3713,18 +3703,6 @@ 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/context_history.rs

@@ -3,13 +3,13 @@ use std::sync::Arc;
 use gpui::{App, Entity, EventEmitter, FocusHandle, Focusable, Subscription, Task, WeakEntity};
 use picker::{Picker, PickerDelegate};
 use project::Project;
-use ui::utils::{DateTimeType, format_distance_from_now};
-use ui::{Avatar, ListItem, ListItemSpacing, prelude::*};
+use ui::utils::{format_distance_from_now, DateTimeType};
+use ui::{prelude::*, Avatar, ListItem, ListItemSpacing};
 use workspace::{Item, Workspace};
 
 use crate::{
-    AssistantPanelDelegate, ContextStore, DEFAULT_TAB_TITLE, RemoteContextMetadata,
-    SavedContextMetadata,
+    AssistantPanelDelegate, ContextStore, RemoteContextMetadata, SavedContextMetadata,
+    DEFAULT_TAB_TITLE,
 };
 
 #[derive(Clone)]
@@ -229,12 +229,10 @@ impl PickerDelegate for SavedContextPickerDelegate {
                                         .into_any_element(),
                                 ]
                             } else {
-                                vec![
-                                    Label::new("Shared by host")
-                                        .color(Color::Muted)
-                                        .size(LabelSize::Small)
-                                        .into_any_element(),
-                                ]
+                                vec![Label::new("Shared by host")
+                                    .color(Color::Muted)
+                                    .size(LabelSize::Small)
+                                    .into_any_element()]
                             }),
                     )
             }

crates/assistant_context_editor/src/context_store.rs

@@ -2,13 +2,13 @@ use crate::{
     AssistantContext, ContextEvent, ContextId, ContextOperation, ContextVersion, SavedContext,
     SavedContextMetadata,
 };
-use anyhow::{Context as _, Result, anyhow};
+use anyhow::{anyhow, Context as _, Result};
 use assistant_slash_command::{SlashCommandId, SlashCommandWorkingSet};
-use client::{Client, TypedEnvelope, proto, telemetry::Telemetry};
+use client::{proto, telemetry::Telemetry, Client, TypedEnvelope};
 use clock::ReplicaId;
 use collections::HashMap;
-use context_server::ContextServerFactoryRegistry;
 use context_server::manager::ContextServerManager;
+use context_server::ContextServerFactoryRegistry;
 use fs::{Fs, RemoveOptions};
 use futures::StreamExt;
 use fuzzy::StringMatchCandidate;
@@ -104,47 +104,52 @@ impl ContextStore {
             const CONTEXT_WATCH_DURATION: Duration = Duration::from_millis(100);
             let (mut events, _) = fs.watch(contexts_dir(), CONTEXT_WATCH_DURATION).await;
 
-            let this = cx.new(|cx: &mut Context<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 mut this = Self {
-                    contexts: Vec::new(),
-                    contexts_metadata: Vec::new(),
-                    context_server_manager,
-                    context_server_slash_command_ids: HashMap::default(),
-                    host_contexts: Vec::new(),
-                    fs,
-                    languages,
-                    slash_commands,
-                    telemetry,
-                    _watch_updates: cx.spawn(async move |this, cx| {
-                        async move {
-                            while events.next().await.is_some() {
-                                this.update(cx, |this, cx| this.reload(cx))?.await.log_err();
+            let this =
+                cx.new(|cx: &mut Context<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 mut this = Self {
+                        contexts: Vec::new(),
+                        contexts_metadata: Vec::new(),
+                        context_server_manager,
+                        context_server_slash_command_ids: HashMap::default(),
+                        host_contexts: Vec::new(),
+                        fs,
+                        languages,
+                        slash_commands,
+                        telemetry,
+                        _watch_updates: cx.spawn(async move |this, cx| {
+                            async move {
+                                while events.next().await.is_some() {
+                                    this.update(cx, |this, cx| this.reload(cx))?.await.log_err();
+                                }
+                                anyhow::Ok(())
                             }
-                            anyhow::Ok(())
-                        }
-                        .log_err()
-                        .await
-                    }),
-                    client_subscription: None,
-                    _project_subscriptions: vec![
-                        cx.subscribe(&project, Self::handle_project_event),
-                    ],
-                    project_is_shared: false,
-                    client: project.read(cx).client(),
-                    project: project.clone(),
-                    prompt_builder,
-                };
-                this.handle_project_shared(project.clone(), cx);
-                this.synchronize_contexts(cx);
-                this.register_context_server_handlers(cx);
-                this.reload(cx).detach_and_log_err(cx);
-                this
-            })?;
+                            .log_err()
+                            .await
+                        }),
+                        client_subscription: None,
+                        _project_subscriptions: vec![
+                            cx.subscribe(&project, Self::handle_project_event)
+                        ],
+                        project_is_shared: false,
+                        client: project.read(cx).client(),
+                        project: project.clone(),
+                        prompt_builder,
+                    };
+                    this.handle_project_shared(project.clone(), cx);
+                    this.synchronize_contexts(cx);
+                    this.register_context_server_handlers(cx);
+                    this.reload(cx).detach_and_log_err(cx);
+                    this
+                })?;
 
             Ok(this)
         })

crates/assistant_context_editor/src/patch.rs

@@ -1,7 +1,7 @@
-use anyhow::{Context as _, Result, anyhow};
+use anyhow::{anyhow, Context as _, Result};
 use collections::HashMap;
 use editor::ProposedChangesEditor;
-use futures::{TryFutureExt as _, future};
+use futures::{future, TryFutureExt as _};
 use gpui::{App, AppContext as _, AsyncApp, Entity, SharedString};
 use language::{AutoindentMode, Buffer, BufferSnapshot};
 use project::{Project, ProjectPath};
@@ -548,7 +548,7 @@ mod tests {
     use super::*;
     use gpui::App;
     use language::{
-        Language, LanguageConfig, LanguageMatcher, language_settings::AllLanguageSettings,
+        language_settings::AllLanguageSettings, Language, LanguageConfig, LanguageMatcher,
     };
     use settings::SettingsStore;
     use ui::BorrowAppContext;

crates/assistant_context_editor/src/slash_command.rs

@@ -3,19 +3,19 @@ use anyhow::Result;
 pub use assistant_slash_command::SlashCommand;
 use assistant_slash_command::{AfterCompletion, SlashCommandLine, SlashCommandWorkingSet};
 use editor::{CompletionProvider, Editor, ExcerptId};
-use fuzzy::{StringMatchCandidate, match_strings};
+use fuzzy::{match_strings, StringMatchCandidate};
 use gpui::{App, AppContext as _, Context, Entity, Task, WeakEntity, Window};
 use language::{Anchor, Buffer, ToPoint};
 use parking_lot::Mutex;
-use project::{CompletionIntent, CompletionSource, lsp_store::CompletionDocumentation};
+use project::{lsp_store::CompletionDocumentation, CompletionIntent, CompletionSource};
 use rope::Point;
 use std::{
     cell::RefCell,
     ops::Range,
     rc::Rc,
     sync::{
-        Arc,
         atomic::{AtomicBool, Ordering::SeqCst},
+        Arc,
     },
 };
 use workspace::Workspace;

crates/assistant_context_editor/src/slash_command_picker.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use assistant_slash_command::SlashCommandWorkingSet;
 use gpui::{AnyElement, AnyView, DismissEvent, SharedString, Task, WeakEntity};
 use picker::{Picker, PickerDelegate, PickerEditorPosition};
-use ui::{ListItem, ListItemSpacing, PopoverMenu, PopoverTrigger, Tooltip, prelude::*};
+use ui::{prelude::*, ListItem, ListItemSpacing, PopoverMenu, PopoverTrigger, Tooltip};
 
 use crate::context_editor::ContextEditor;
 

crates/assistant_eval/Cargo.toml

@@ -13,26 +13,27 @@ name = "assistant_eval"
 path = "src/main.rs"
 
 [dependencies]
-agent.workspace = true
 anyhow.workspace = true
+assistant2.workspace = true
 assistant_tool.workspace = true
 assistant_tools.workspace = true
 clap.workspace = true
 client.workspace = true
 collections.workspace = true
 context_server.workspace = true
-dap.workspace = true
 env_logger.workspace = true
 fs.workspace = true
 futures.workspace = true
 gpui.workspace = true
 gpui_tokio.workspace = true
+itertools.workspace = true
 language.workspace = true
 language_model.workspace = true
 language_models.workspace = true
 node_runtime.workspace = true
 project.workspace = true
 prompt_store.workspace = true
+regex.workspace = true
 release_channel.workspace = true
 reqwest_client.workspace = true
 serde.workspace = true
@@ -40,7 +41,4 @@ serde_json.workspace = true
 serde_json_lenient.workspace = true
 settings.workspace = true
 smol.workspace = true
-tempfile.workspace = true
 util.workspace = true
-walkdir.workspace = true
-workspace-hack.workspace = true

crates/assistant_eval/README.md

@@ -1,25 +1,34 @@
 # Tool Evals
 
-A framework for evaluating and benchmarking the agent panel generations.
+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. Setting up test code and repositories
+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 and tool usage
+4. Collecting metrics on performance
 5. Evaluating results against known good solutions
 
 ## How It Works
 
 The system consists of several key components:
 
-- **Eval**: Loads exercises from the zed-ace-framework repository, creates temporary repos, and executes evaluations
+- **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**: Evaluates AI-generated solutions against reference implementations and assigns scores
-- **Templates**: Defines evaluation frameworks for different tasks (Project Creation, Code Modification, Conversational Guidance)
+- **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
 
@@ -27,7 +36,6 @@ The system consists of several key components:
 
 - Rust and Cargo
 - Git
-- Python (for report generation)
 - Network access to clone repositories
 - Appropriate API keys for language models and git services (Anthropic, GitHub, etc.)
 
@@ -35,34 +43,35 @@ The system consists of several key components:
 
 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 Evaluations
+### Running a Single Evaluation
+
+To run a specific evaluation:
 
 ```bash
-# Run all tests
-cargo run -p assistant_eval -- --all
-
-# Run only specific languages
-cargo run -p assistant_eval -- --all --languages python,rust
-
-# Limit concurrent evaluations
-cargo run -p assistant_eval -- --all --concurrency 5
-
-# Limit number of exercises per language
-cargo run -p assistant_eval -- --all --max-exercises-per-language 3
+cargo run -p assistant_eval -- bubbletea-add-set-window-title
 ```
 
-### Evaluation Template Types
+The arguments are regex patterns for the evaluation names to run, so to run all evaluations that contain `bubbletea`, run:
 
-The system supports three types of evaluation templates:
+```bash
+cargo run -p assistant_eval -- bubbletea
+```
 
-1. **ProjectCreation**: Tests the model's ability to create new implementations from scratch
-2. **CodeModification**: Tests the model's ability to modify existing code to meet new requirements
-3. **ConversationalGuidance**: Tests the model's ability to provide guidance without writing code
+To run all evaluations:
 
-### Support Repo
+```bash
+cargo run -p assistant_eval -- --all
+```
 
-The [zed-industries/zed-ace-framework](https://github.com/zed-industries/zed-ace-framework) contains the analytics and reporting scripts.
+## 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

@@ -6,6 +6,15 @@ fn main() {
     if cfg!(target_os = "macos") {
         println!("cargo:rustc-env=MACOSX_DEPLOYMENT_TARGET=10.15.7");
 
+        println!("cargo:rerun-if-env-changed=ZED_BUNDLE");
+        if std::env::var("ZED_BUNDLE").ok().as_deref() == Some("true") {
+            // Find WebRTC.framework in the Frameworks folder when running as part of an application bundle.
+            println!("cargo:rustc-link-arg=-Wl,-rpath,@executable_path/../Frameworks");
+        } else {
+            // Find WebRTC.framework as a sibling of the executable when running outside of an application bundle.
+            println!("cargo:rustc-link-arg=-Wl,-rpath,@executable_path");
+        }
+
         // Weakly link ReplayKit to ensure Zed can be used on macOS 10.15+.
         println!("cargo:rustc-link-arg=-Wl,-weak_framework,ReplayKit");
 

crates/assistant_eval/src/eval.rs

@@ -1,8 +1,6 @@
-use crate::git_commands::{run_git, setup_temp_repo};
 use crate::headless_assistant::{HeadlessAppState, HeadlessAssistant};
-use crate::{get_exercise_language, get_exercise_name, templates_eval::Template};
-use agent::RequestKind;
-use anyhow::{Result, anyhow};
+use anyhow::anyhow;
+use assistant2::RequestKind;
 use collections::HashMap;
 use gpui::{App, Task};
 use language_model::{LanguageModel, TokenUsage};
@@ -12,26 +10,19 @@ use std::{
     io::Write,
     path::{Path, PathBuf},
     sync::Arc,
-    time::{Duration, SystemTime},
+    time::Duration,
 };
+use util::command::new_smol_command;
 
-#[derive(Debug, Serialize, Deserialize, Clone)]
-pub struct EvalResult {
-    pub exercise_name: String,
-    pub template_name: String,
-    pub score: String,
-    pub diff: String,
-    pub assistant_response: String,
-    pub elapsed_time_ms: u128,
-    pub timestamp: u128,
-    // Token usage fields
-    pub input_tokens: usize,
-    pub output_tokens: usize,
-    pub total_tokens: usize,
-    pub tool_use_counts: usize,
-    pub judge_model_name: String, // Added field for judge model name
+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,
@@ -47,31 +38,19 @@ pub struct EvalSetup {
     pub base_sha: String,
 }
 
-pub struct Eval {
-    pub repo_path: PathBuf,
-    pub eval_setup: EvalSetup,
-    pub user_prompt: String,
-}
-
 impl Eval {
-    // Keep this method for potential future use, but mark it as intentionally unused
-    #[allow(dead_code)]
-    pub async fn load(_name: String, path: PathBuf, repos_dir: &Path) -> Result<Self> {
+    /// 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)?;
-
-        // Move this internal function inside the load method since it's only used here
-        fn repo_dir_name(url: &str) -> String {
-            url.trim_start_matches("https://")
-                .replace(|c: char| !c.is_alphanumeric(), "_")
-        }
-
         let repo_path = repos_dir.join(repo_dir_name(&eval_setup.url));
-
         Ok(Eval {
+            name,
+            path,
             repo_path,
             eval_setup,
             user_prompt,
@@ -83,9 +62,9 @@ impl Eval {
         app_state: Arc<HeadlessAppState>,
         model: Arc<dyn LanguageModel>,
         cx: &mut App,
-    ) -> Task<Result<EvalOutput>> {
+    ) -> Task<anyhow::Result<EvalOutput>> {
         cx.spawn(async move |cx| {
-            run_git(&self.repo_path, &["checkout", &self.eval_setup.base_sha]).await?;
+            checkout_repo(&self.eval_setup, &self.repo_path).await?;
 
             let (assistant, done_rx) =
                 cx.update(|cx| HeadlessAssistant::new(app_state.clone(), cx))??;
@@ -125,43 +104,9 @@ impl Eval {
 
             done_rx.recv().await??;
 
-            // Add this section to check untracked files
-            println!("Checking for untracked files:");
-            let untracked = run_git(
-                &self.repo_path,
-                &["ls-files", "--others", "--exclude-standard"],
-            )
-            .await?;
-            if untracked.is_empty() {
-                println!("No untracked files found");
-            } else {
-                // Add all files to git so they appear in the diff
-                println!("Adding untracked files to git");
-                run_git(&self.repo_path, &["add", "."]).await?;
-            }
-
-            // get git status
-            let _status = run_git(&self.repo_path, &["status", "--short"]).await?;
-
             let elapsed_time = start_time.elapsed()?;
 
-            // Get diff of staged changes (the files we just added)
-            let staged_diff = run_git(&self.repo_path, &["diff", "--staged"]).await?;
-
-            // Get diff of unstaged changes
-            let unstaged_diff = run_git(&self.repo_path, &["diff"]).await?;
-
-            // Combine both diffs
-            let diff = if unstaged_diff.is_empty() {
-                staged_diff
-            } else if staged_diff.is_empty() {
-                unstaged_diff
-            } else {
-                format!(
-                    "# Staged changes\n{}\n\n# Unstaged changes\n{}",
-                    staged_diff, unstaged_diff
-                )
-            };
+            let diff = query_git(&self.repo_path, vec!["diff"]).await?;
 
             assistant.update(cx, |assistant, cx| {
                 let thread = assistant.thread.read(cx);
@@ -187,9 +132,12 @@ impl Eval {
 }
 
 impl EvalOutput {
-    // Keep this method for potential future use, but mark it as intentionally unused
-    #[allow(dead_code)]
-    pub fn save_to_directory(&self, output_dir: &Path, eval_output_value: String) -> Result<()> {
+    // 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)?;
 
@@ -244,305 +192,76 @@ impl EvalOutput {
     }
 }
 
-pub async fn read_instructions(exercise_path: &Path) -> Result<String> {
-    let instructions_path = exercise_path.join(".docs").join("instructions.md");
-    println!("Reading instructions from: {}", instructions_path.display());
-    let instructions = smol::unblock(move || std::fs::read_to_string(&instructions_path)).await?;
-    Ok(instructions)
+fn repo_dir_name(url: &str) -> String {
+    url.trim_start_matches("https://")
+        .replace(|c: char| !c.is_alphanumeric(), "_")
 }
 
-pub async fn read_example_solution(exercise_path: &Path, language: &str) -> Result<String> {
-    // Map the language to the file extension
-    let language_extension = match language {
-        "python" => "py",
-        "go" => "go",
-        "rust" => "rs",
-        "typescript" => "ts",
-        "javascript" => "js",
-        "ruby" => "rb",
-        "php" => "php",
-        "bash" => "sh",
-        "multi" => "diff",
-        "internal" => "diff",
-        _ => return Err(anyhow!("Unsupported language: {}", language)),
-    };
-    let example_path = exercise_path
-        .join(".meta")
-        .join(format!("example.{}", language_extension));
-    println!("Reading example solution from: {}", example_path.display());
-    let example = smol::unblock(move || std::fs::read_to_string(&example_path)).await?;
-    Ok(example)
-}
-
-pub async fn save_eval_results(exercise_path: &Path, results: Vec<EvalResult>) -> Result<()> {
-    let eval_dir = exercise_path.join("evaluation");
-    fs::create_dir_all(&eval_dir)?;
-
-    let eval_file = eval_dir.join("evals.json");
-
-    println!("Saving evaluation results to: {}", eval_file.display());
-    println!(
-        "Results to save: {} evaluations for exercise path: {}",
-        results.len(),
-        exercise_path.display()
-    );
-
-    // Check file existence before reading/writing
-    if eval_file.exists() {
-        println!("Existing evals.json file found, will update it");
+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 {
-        println!("No existing evals.json file found, will create new one");
-    }
-
-    // Structure to organize evaluations by test name and timestamp
-    let mut eval_data: serde_json::Value = if eval_file.exists() {
-        let content = fs::read_to_string(&eval_file)?;
-        serde_json::from_str(&content).unwrap_or_else(|_| serde_json::json!({}))
-    } else {
-        serde_json::json!({})
-    };
-
-    // Get current timestamp for this batch of results
-    let timestamp = SystemTime::now()
-        .duration_since(SystemTime::UNIX_EPOCH)?
-        .as_millis()
-        .to_string();
-
-    // Group the new results by test name (exercise name)
-    for result in results {
-        let exercise_name = &result.exercise_name;
-        let template_name = &result.template_name;
-
-        println!(
-            "Adding result: exercise={}, template={}",
-            exercise_name, template_name
-        );
-
-        // Ensure the exercise entry exists
-        if eval_data.get(exercise_name).is_none() {
-            eval_data[exercise_name] = serde_json::json!({});
+        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
+            ));
         }
 
-        // Ensure the timestamp entry exists as an object
-        if eval_data[exercise_name].get(&timestamp).is_none() {
-            eval_data[exercise_name][&timestamp] = serde_json::json!({});
-        }
-
-        // Add this result under the timestamp with template name as key
-        eval_data[exercise_name][&timestamp][template_name] = serde_json::to_value(&result)?;
+        // 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?;
     }
 
-    // Write back to file with pretty formatting
-    let json_content = serde_json::to_string_pretty(&eval_data)?;
-    match fs::write(&eval_file, json_content) {
-        Ok(_) => println!("✓ Successfully saved results to {}", eval_file.display()),
-        Err(e) => println!("✗ Failed to write results file: {}", e),
-    }
+    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(())
 }
 
-pub async fn run_exercise_eval(
-    exercise_path: PathBuf,
-    template: Template,
-    model: Arc<dyn LanguageModel>,
-    judge_model: Arc<dyn LanguageModel>,
-    app_state: Arc<HeadlessAppState>,
-    base_sha: String,
-    _framework_path: PathBuf,
-    cx: gpui::AsyncApp,
-) -> Result<EvalResult> {
-    let exercise_name = get_exercise_name(&exercise_path);
-    let language = get_exercise_language(&exercise_path)?;
-    let mut instructions = read_instructions(&exercise_path).await?;
-    instructions.push_str(&format!(
-        "\n\nWhen writing the code for this prompt, use {} to achieve the goal.",
-        language
-    ));
-    let example_solution = read_example_solution(&exercise_path, &language).await?;
-
-    println!(
-        "Running evaluation for exercise: {} with template: {}",
-        exercise_name, template.name
-    );
-
-    // Create temporary directory with exercise files
-    let temp_dir = setup_temp_repo(&exercise_path, &base_sha).await?;
-    let temp_path = temp_dir.path().to_path_buf();
-
-    if template.name == "ProjectCreation" {
-        for entry in fs::read_dir(&temp_path)? {
-            let entry = entry?;
-            let path = entry.path();
-
-            // Skip directories that start with dot (like .docs, .meta, .git)
-            if path.is_dir()
-                && path
-                    .file_name()
-                    .and_then(|name| name.to_str())
-                    .map(|name| name.starts_with("."))
-                    .unwrap_or(false)
-            {
-                continue;
-            }
-
-            // Delete regular files
-            if path.is_file() {
-                println!("  Deleting file: {}", path.display());
-                fs::remove_file(path)?;
-            }
-        }
-
-        // Commit the deletion so it shows up in the diff
-        run_git(&temp_path, &["add", "."]).await?;
-        run_git(
-            &temp_path,
-            &["commit", "-m", "Remove root files for clean slate"],
-        )
+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?;
-    }
-
-    let local_commit_sha = run_git(&temp_path, &["rev-parse", "HEAD"]).await?;
-
-    // Prepare prompt based on template
-    let prompt = match template.name {
-        "ProjectCreation" => format!(
-            "I need to create a new implementation for this exercise. Please create all the necessary files in the best location.\n\n{}",
-            instructions
-        ),
-        "CodeModification" => format!(
-            "I need help updating my code to meet these requirements. Please modify the appropriate files:\n\n{}",
-            instructions
-        ),
-        "ConversationalGuidance" => format!(
-            "I'm trying to solve this coding exercise but I'm not sure where to start. Can you help me understand the requirements and guide me through the solution process without writing code for me?\n\n{}",
-            instructions
-        ),
-        _ => instructions.clone(),
-    };
-
-    let start_time = SystemTime::now();
-
-    // Create a basic eval struct to work with the existing system
-    let eval = Eval {
-        repo_path: temp_path.clone(),
-        eval_setup: EvalSetup {
-            url: format!("file://{}", temp_path.display()),
-            base_sha: local_commit_sha, // Use the local commit SHA instead of the framework base SHA
-        },
-        user_prompt: prompt,
-    };
-
-    // Run the evaluation
-    let eval_output = cx
-        .update(|cx| eval.run(app_state.clone(), model.clone(), cx))?
-        .await?;
-
-    // Get diff from git
-    let diff = eval_output.diff.clone();
-
-    // For project creation template, we need to compare with reference implementation
-    let judge_output = if template.name == "ProjectCreation" {
-        let project_judge_prompt = template
-            .content
-            .replace(
-                "<!-- ```requirements go here``` -->",
-                &format!("```\n{}\n```", instructions),
-            )
-            .replace(
-                "<!-- ```reference code goes here``` -->",
-                &format!("```{}\n{}\n```", language, example_solution),
-            )
-            .replace(
-                "<!-- ```git diff goes here``` -->",
-                &format!("```\n{}\n```", diff),
-            );
-
-        // Use the run_with_prompt method which we'll add to judge.rs
-        let judge = crate::judge::Judge {
-            original_diff: None,
-            original_message: Some(project_judge_prompt),
-            model: judge_model.clone(),
-        };
-
-        cx.update(|cx| judge.run_with_prompt(cx))?.await?
-    } else if template.name == "CodeModification" {
-        // For CodeModification, we'll compare the example solution with the LLM-generated solution
-        let code_judge_prompt = template
-            .content
-            .replace(
-                "<!-- ```reference code goes here``` -->",
-                &format!("```{}\n{}\n```", language, example_solution),
-            )
-            .replace(
-                "<!-- ```git diff goes here``` -->",
-                &format!("```\n{}\n```", diff),
-            );
-
-        // Use the run_with_prompt method
-        let judge = crate::judge::Judge {
-            original_diff: None,
-            original_message: Some(code_judge_prompt),
-            model: judge_model.clone(),
-        };
-
-        cx.update(|cx| judge.run_with_prompt(cx))?.await?
+    if exit_status.success() {
+        Ok(())
     } else {
-        // Conversational template
-        let conv_judge_prompt = template
-            .content
-            .replace(
-                "<!-- ```query goes here``` -->",
-                &format!("```\n{}\n```", instructions),
-            )
-            .replace(
-                "<!-- ```transcript goes here``` -->",
-                &format!("```\n{}\n```", eval_output.last_message),
-            )
-            .replace(
-                "<!-- ```git diff goes here``` -->",
-                &format!("```\n{}\n```", diff),
-            );
-
-        // Use the run_with_prompt method for consistency
-        let judge = crate::judge::Judge {
-            original_diff: None,
-            original_message: Some(conv_judge_prompt),
-            model: judge_model.clone(),
-        };
-
-        cx.update(|cx| judge.run_with_prompt(cx))?.await?
-    };
-
-    let elapsed_time = start_time.elapsed()?;
-
-    // Calculate total tokens as the sum of input and output tokens
-    let input_tokens = eval_output.token_usage.input_tokens;
-    let output_tokens = eval_output.token_usage.output_tokens;
-    let tool_use_counts = eval_output.tool_use_counts.values().sum::<u32>();
-    let total_tokens = input_tokens + output_tokens;
-
-    // Get judge model name
-    let judge_model_name = judge_model.id().0.to_string();
-
-    // Save results to evaluation directory
-    let result = EvalResult {
-        exercise_name: exercise_name.clone(),
-        template_name: template.name.to_string(),
-        score: judge_output.trim().to_string(),
-        diff,
-        assistant_response: eval_output.last_message.clone(),
-        elapsed_time_ms: elapsed_time.as_millis(),
-        timestamp: SystemTime::now()
-            .duration_since(SystemTime::UNIX_EPOCH)?
-            .as_millis(),
-        // Convert u32 token counts to usize
-        input_tokens: input_tokens.try_into().unwrap(),
-        output_tokens: output_tokens.try_into().unwrap(),
-        total_tokens: total_tokens.try_into().unwrap(),
-        tool_use_counts: tool_use_counts.try_into().unwrap(),
-        judge_model_name, // Add judge model name to result
-    };
-
-    Ok(result)
+        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/get_exercise.rs

@@ -1,149 +0,0 @@
-use anyhow::{Result, anyhow};
-use std::{
-    fs,
-    path::{Path, PathBuf},
-};
-
-pub fn get_exercise_name(exercise_path: &Path) -> String {
-    exercise_path
-        .file_name()
-        .unwrap_or_default()
-        .to_string_lossy()
-        .to_string()
-}
-
-pub fn get_exercise_language(exercise_path: &Path) -> Result<String> {
-    // Extract the language from path (data/python/exercises/... => python)
-    let parts: Vec<_> = exercise_path.components().collect();
-
-    for (i, part) in parts.iter().enumerate() {
-        if i > 0 && part.as_os_str() == "eval_code" {
-            if i + 1 < parts.len() {
-                let language = parts[i + 1].as_os_str().to_string_lossy().to_string();
-                return Ok(language);
-            }
-        }
-    }
-
-    Err(anyhow!(
-        "Could not determine language from path: {:?}",
-        exercise_path
-    ))
-}
-
-pub fn find_exercises(
-    framework_path: &Path,
-    languages: &[&str],
-    max_per_language: Option<usize>,
-) -> Result<Vec<PathBuf>> {
-    let mut all_exercises = Vec::new();
-
-    println!("Searching for exercises in languages: {:?}", languages);
-
-    for language in languages {
-        let language_dir = framework_path
-            .join("eval_code")
-            .join(language)
-            .join("exercises")
-            .join("practice");
-
-        println!("Checking language directory: {:?}", language_dir);
-        if !language_dir.exists() {
-            println!("Warning: Language directory not found: {:?}", language_dir);
-            continue;
-        }
-
-        let mut exercises = Vec::new();
-        match fs::read_dir(&language_dir) {
-            Ok(entries) => {
-                for entry_result in entries {
-                    match entry_result {
-                        Ok(entry) => {
-                            let path = entry.path();
-
-                            if path.is_dir() {
-                                // Special handling for "internal" directory
-                                if *language == "internal" {
-                                    // Check for repo_info.json to validate it's an internal exercise
-                                    let repo_info_path = path.join(".meta").join("repo_info.json");
-                                    let instructions_path =
-                                        path.join(".docs").join("instructions.md");
-
-                                    if repo_info_path.exists() && instructions_path.exists() {
-                                        exercises.push(path);
-                                    }
-                                } else {
-                                    // Map the language to the file extension - original code
-                                    let language_extension = match *language {
-                                        "python" => "py",
-                                        "go" => "go",
-                                        "rust" => "rs",
-                                        "typescript" => "ts",
-                                        "javascript" => "js",
-                                        "ruby" => "rb",
-                                        "php" => "php",
-                                        "bash" => "sh",
-                                        "multi" => "diff",
-                                        _ => continue, // Skip unsupported languages
-                                    };
-
-                                    // Check if this is a valid exercise with instructions and example
-                                    let instructions_path =
-                                        path.join(".docs").join("instructions.md");
-                                    let has_instructions = instructions_path.exists();
-                                    let example_path = path
-                                        .join(".meta")
-                                        .join(format!("example.{}", language_extension));
-                                    let has_example = example_path.exists();
-
-                                    if has_instructions && has_example {
-                                        exercises.push(path);
-                                    }
-                                }
-                            }
-                        }
-                        Err(err) => println!("Error reading directory entry: {}", err),
-                    }
-                }
-            }
-            Err(err) => println!(
-                "Error reading directory {}: {}",
-                language_dir.display(),
-                err
-            ),
-        }
-
-        // Sort exercises by name for consistent selection
-        exercises.sort_by(|a, b| {
-            let a_name = a.file_name().unwrap_or_default().to_string_lossy();
-            let b_name = b.file_name().unwrap_or_default().to_string_lossy();
-            a_name.cmp(&b_name)
-        });
-
-        // Apply the limit if specified
-        if let Some(limit) = max_per_language {
-            if exercises.len() > limit {
-                println!(
-                    "Limiting {} exercises to {} for language {}",
-                    exercises.len(),
-                    limit,
-                    language
-                );
-                exercises.truncate(limit);
-            }
-        }
-
-        println!(
-            "Found {} exercises for language {}: {:?}",
-            exercises.len(),
-            language,
-            exercises
-                .iter()
-                .map(|p| p.file_name().unwrap_or_default().to_string_lossy())
-                .collect::<Vec<_>>()
-        );
-        all_exercises.extend(exercises);
-    }
-
-    Ok(all_exercises)
-}

crates/assistant_eval/src/git_commands.rs

@@ -1,125 +0,0 @@
-use anyhow::{Result, anyhow};
-use serde::Deserialize;
-use std::{fs, path::Path};
-use tempfile::TempDir;
-use util::command::new_smol_command;
-use walkdir::WalkDir;
-
-#[derive(Debug, Deserialize)]
-pub struct SetupConfig {
-    #[serde(rename = "base.sha")]
-    pub base_sha: String,
-}
-
-#[derive(Debug, Deserialize)]
-pub struct RepoInfo {
-    pub remote_url: String,
-    pub head_sha: String,
-}
-
-pub async fn run_git(repo_path: &Path, args: &[&str]) -> Result<String> {
-    let output = new_smol_command("git")
-        .current_dir(repo_path)
-        .args(args)
-        .output()
-        .await?;
-
-    if output.status.success() {
-        Ok(String::from_utf8(output.stdout)?.trim().to_string())
-    } else {
-        Err(anyhow!(
-            "Git command failed: {} with status: {}",
-            args.join(" "),
-            output.status
-        ))
-    }
-}
-
-pub async fn read_base_sha(framework_path: &Path) -> Result<String> {
-    let setup_path = framework_path.join("setup.json");
-    let setup_content = smol::unblock(move || std::fs::read_to_string(&setup_path)).await?;
-    let setup_config: SetupConfig = serde_json_lenient::from_str_lenient(&setup_content)?;
-    Ok(setup_config.base_sha)
-}
-
-pub async fn read_repo_info(exercise_path: &Path) -> Result<RepoInfo> {
-    let repo_info_path = exercise_path.join(".meta").join("repo_info.json");
-    println!("Reading repo info from: {}", repo_info_path.display());
-    let repo_info_content = smol::unblock(move || std::fs::read_to_string(&repo_info_path)).await?;
-    let repo_info: RepoInfo = serde_json_lenient::from_str_lenient(&repo_info_content)?;
-
-    // Remove any quotes from the strings
-    let remote_url = repo_info.remote_url.trim_matches('"').to_string();
-    let head_sha = repo_info.head_sha.trim_matches('"').to_string();
-
-    Ok(RepoInfo {
-        remote_url,
-        head_sha,
-    })
-}
-
-pub async fn setup_temp_repo(exercise_path: &Path, _base_sha: &str) -> Result<TempDir> {
-    let temp_dir = TempDir::new()?;
-
-    // Check if this is an internal exercise by looking for repo_info.json
-    let repo_info_path = exercise_path.join(".meta").join("repo_info.json");
-    if repo_info_path.exists() {
-        // This is an internal exercise, handle it differently
-        let repo_info = read_repo_info(exercise_path).await?;
-
-        // Clone the repository to the temp directory
-        let url = repo_info.remote_url;
-        let clone_path = temp_dir.path();
-        println!(
-            "Cloning repository from {} to {}",
-            url,
-            clone_path.display()
-        );
-        run_git(
-            &std::env::current_dir()?,
-            &["clone", &url, &clone_path.to_string_lossy()],
-        )
-        .await?;
-
-        // Checkout the specified commit
-        println!("Checking out commit: {}", repo_info.head_sha);
-        run_git(temp_dir.path(), &["checkout", &repo_info.head_sha]).await?;
-
-        println!("Successfully set up internal repository");
-    } else {
-        // Original code for regular exercises
-        // Copy the exercise files to the temp directory, excluding .docs and .meta
-        for entry in WalkDir::new(exercise_path).min_depth(0).max_depth(10) {
-            let entry = entry?;
-            let source_path = entry.path();
-
-            // Skip .docs and .meta directories completely
-            if source_path.starts_with(exercise_path.join(".docs"))
-                || source_path.starts_with(exercise_path.join(".meta"))
-            {
-                continue;
-            }
-
-            if source_path.is_file() {
-                let relative_path = source_path.strip_prefix(exercise_path)?;
-                let dest_path = temp_dir.path().join(relative_path);
-
-                // Make sure parent directories exist
-                if let Some(parent) = dest_path.parent() {
-                    fs::create_dir_all(parent)?;
-                }
-
-                fs::copy(source_path, dest_path)?;
-            }
-        }
-
-        // Initialize git repo in the temp directory
-        run_git(temp_dir.path(), &["init"]).await?;
-        run_git(temp_dir.path(), &["add", "."]).await?;
-        run_git(temp_dir.path(), &["commit", "-m", "Initial commit"]).await?;
-
-        println!("Created temp repo without .docs and .meta directories");
-    }
-
-    Ok(temp_dir)
-}

crates/assistant_eval/src/headless_assistant.rs

@@ -1,11 +1,10 @@
-use agent::{RequestKind, Thread, ThreadEvent, ThreadStore};
 use anyhow::anyhow;
+use assistant2::{RequestKind, Thread, ThreadEvent, ThreadStore};
 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 gpui::{prelude::*, App, AsyncApp, Entity, SemanticVersion, Subscription, Task};
 use language::LanguageRegistry;
 use language_model::{
     AuthenticateError, LanguageModel, LanguageModelProviderId, LanguageModelRegistry,
@@ -51,7 +50,6 @@ impl HeadlessAssistant {
             app_state.node_runtime.clone(),
             app_state.user_store.clone(),
             app_state.languages.clone(),
-            Arc::new(DapRegistry::default()),
             app_state.fs.clone(),
             env,
             cx,
@@ -102,40 +100,6 @@ impl HeadlessAssistant {
                     thread.use_pending_tools(cx);
                 });
             }
-            ThreadEvent::ToolConfirmationNeeded => {
-                // Automatically approve all tools that need confirmation in headless mode
-                println!("Tool confirmation needed - automatically approving in headless mode");
-
-                // Get the tools needing confirmation
-                let tools_needing_confirmation: Vec<_> = thread
-                    .read(cx)
-                    .tools_needing_confirmation()
-                    .cloned()
-                    .collect();
-
-                // Run each tool that needs confirmation
-                for tool_use in tools_needing_confirmation {
-                    if let Some(tool) = thread.read(cx).tools().tool(&tool_use.name, cx) {
-                        thread.update(cx, |thread, cx| {
-                            println!("Auto-approving tool: {}", tool_use.name);
-
-                            // Create a request to send to the tool
-                            let request = thread.to_completion_request(RequestKind::Chat, cx);
-                            let messages = Arc::new(request.messages);
-
-                            // Run the tool
-                            thread.run_tool(
-                                tool_use.id.clone(),
-                                tool_use.ui_text.clone(),
-                                tool_use.input.clone(),
-                                &messages,
-                                tool,
-                                cx,
-                            );
-                        });
-                    }
-                }
-            }
             ThreadEvent::ToolFinished {
                 tool_use_id,
                 pending_tool_use,
@@ -156,15 +120,11 @@ impl HeadlessAssistant {
                 }
                 if thread.read(cx).all_tools_finished() {
                     let model_registry = LanguageModelRegistry::read_global(cx);
-                    if let Some(model) = model_registry.default_model() {
+                    if let Some(model) = model_registry.active_model() {
                         thread.update(cx, |thread, cx| {
-                            thread.attach_tool_results(cx);
-                            thread.send_to_model(model.model, RequestKind::Chat, cx);
+                            thread.attach_tool_results(vec![], cx);
+                            thread.send_to_model(model, RequestKind::Chat, cx);
                         });
-                    } else {
-                        println!(
-                            "Warning: No active language model available to continue conversation"
-                        );
                     }
                 }
             }
@@ -205,7 +165,7 @@ pub fn init(cx: &mut App) -> Arc<HeadlessAppState> {
     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);
+    assistant2::init(fs.clone(), client.clone(), prompt_builder.clone(), cx);
 
     Arc::new(HeadlessAppState {
         languages,