wip

This avoids inline completions being shown (and overriding `<tab>`
behavior) when a snippet is active and the user wants to go through
snippet placeholders with `<tab>`.

Easy to reproduce:

Open a Rust file and use the `tfn` snippet to produce a test function.
Delete the placeholder. Without the change here, the inline provider
would suggest a function name. If you `<tab>`, you accept it, but then
you can't `<tab>` into the function body.

With this change the inline completions are deactivated as long as a
snippet is active.

Closes #19484 

Release Notes:

- Fixed inline completions (Copilot, Supermaven, ...) taking over when a
snippet completion was active. That resulted in `tab` not working to
jump to the next placeholder in the snippet.

.github/ISSUE_TEMPLATE/0_feature_request.yml

@@ -15,6 +15,13 @@ body:
       description: A clear and concise description of what you want to happen.
     validations:
       required: true
+  - type: textarea
+    id: environment
+    attributes:
+      label: Environment
+      description: Run the `copy system specs into clipboard` command palette action and paste the output in the field below.
+    validations:
+      required: true
   - type: textarea
     attributes:
       label: |

.github/ISSUE_TEMPLATE/1_bug_report.yml

@@ -2,7 +2,7 @@ name: Bug Report
 description: |
   Use this template for **non-crash-related** bug reports.
   Tip: open this issue template from within Zed with the `file bug report` command palette action.
-labels: ["admin read", "triage", "defect"]
+labels: ["admin read", "triage", "bug"]
 body:
   - type: checkboxes
     attributes:
@@ -38,9 +38,12 @@ body:
         Linux: `~/.local/share/zed/logs/Zed.log` or $XDG_DATA_HOME
         If you only need the most recent lines, you can run the `zed: open log` command palette action to see the last 1000.
       value: |
-        <details><summary>Zed.log</summary><pre>
-        <!-- Click below this line and paste or drag-and-drop your log-->
+        <details><summary>Zed.log</summary>
 
-        <!-- Click above this line and paste or drag-and-drop your log--></pre></details>
+        <!-- Click below this line and paste or drag-and-drop your log-->
+        ```
+
+        ```
+        <!-- Click above this line and paste or drag-and-drop your log--></details>
     validations:
       required: false

.github/ISSUE_TEMPLATE/2_crash_report.yml

@@ -1,7 +1,7 @@
 name: Crash Report
 description: |
   Use this template for crash reports.
-labels: ["admin read", "triage", "defect", "panic / crash"]
+labels: ["admin read", "triage", "bug", "panic / crash"]
 body:
   - type: checkboxes
     attributes:
@@ -31,9 +31,12 @@ body:
         Linux: `~/.local/share/zed/logs/Zed.log` or $XDG_DATA_HOME
         If you only need the most recent lines, you can run the `zed: open log` command palette action to see the last 1000.
       value: |
-        <details><summary>Zed.log</summary><pre>
-        <!-- Click below this line and paste or drag-and-drop your log-->
+        <details><summary>Zed.log</summary>
 
-        <!-- Click above this line and paste or drag-and-drop your log--></pre></details>
+        <!-- Click below this line and paste or drag-and-drop your log-->
+        ```
+
+        ```
+        <!-- Click above this line and paste or drag-and-drop your log--></details>
     validations:
       required: false

.github/actions/run_tests/action.yml

@@ -10,7 +10,7 @@ runs:
         cargo install cargo-nextest
 
     - name: Install Node
-      uses: actions/setup-node@0a44ba7841725637a19e28fa30b79a866c81b0a6 # v4
+      uses: actions/setup-node@39370e3970a6d050c480ffad4ff0ed4d3fdee5af # v4
       with:
         node-version: "18"
 

.github/workflows/bump_patch_version.yml

@@ -43,6 +43,8 @@ jobs:
           esac
           which cargo-set-version > /dev/null || cargo install cargo-edit
           output=$(cargo set-version -p zed --bump patch 2>&1 | sed 's/.* //')
+          export GIT_COMMITTER_NAME="Zed Bot"
+          export GIT_COMMITTER_EMAIL="hi@zed.dev"
           git commit -am "Bump to $output for @$GITHUB_ACTOR" --author "Zed Bot <hi@zed.dev>"
           git tag v${output}${tag_suffix}
           git push origin HEAD v${output}${tag_suffix}

.github/workflows/ci.yml

@@ -13,7 +13,7 @@ on:
     branches:
       - "**"
     paths-ignore:
-      - "docs/**"
+      - "docs/**/*"
       - ".github/workflows/community_*"
 
 concurrency:
@@ -25,6 +25,7 @@ env:
   CARGO_TERM_COLOR: always
   CARGO_INCREMENTAL: 0
   RUST_BACKTRACE: 1
+  RUSTFLAGS: "-D warnings"
 
 jobs:
   migration_checks:
@@ -116,13 +117,13 @@ jobs:
         uses: ./.github/actions/run_tests
 
       - name: Build collab
-        run: RUSTFLAGS="-D warnings" cargo build -p collab
+        run: cargo build -p collab
 
       - name: Build other binaries and features
         run: |
-          RUSTFLAGS="-D warnings" cargo build --workspace --bins --all-features
+          cargo build --workspace --bins --all-features
           cargo check -p gpui --features "macos-blade"
-          RUSTFLAGS="-D warnings" cargo build -p remote_server
+          cargo build -p remote_server
 
   linux_tests:
     timeout-minutes: 60
@@ -155,7 +156,7 @@ jobs:
         uses: ./.github/actions/run_tests
 
       - name: Build Zed
-        run: RUSTFLAGS="-D warnings" cargo build -p zed
+        run: cargo build -p zed
 
   build_remote_server:
     timeout-minutes: 60
@@ -182,7 +183,7 @@ jobs:
         run: ./script/remote-server && ./script/install-mold 2.34.0
 
       - name: Build Remote Server
-        run: RUSTFLAGS="-D warnings" cargo build -p remote_server
+        run: cargo build -p remote_server
 
   # todo(windows): Actually run the tests
   windows_tests:
@@ -191,6 +192,9 @@ jobs:
     if: github.repository_owner == 'zed-industries'
     runs-on: hosted-windows-1
     steps:
+      # more info here:- https://github.com/rust-lang/cargo/issues/13020
+      - name: Enable longer pathnames for git
+        run: git config --system core.longpaths true
       - name: Checkout repo
         uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
@@ -207,7 +211,7 @@ jobs:
         run: cargo xtask clippy
 
       - name: Build Zed
-        run: $env:RUSTFLAGS="-D warnings"; cargo build
+        run: cargo build
 
   bundle-mac:
     timeout-minutes: 60
@@ -228,7 +232,7 @@ jobs:
       DIGITALOCEAN_SPACES_SECRET_KEY: ${{ secrets.DIGITALOCEAN_SPACES_SECRET_KEY }}
     steps:
       - name: Install Node
-        uses: actions/setup-node@0a44ba7841725637a19e28fa30b79a866c81b0a6 # v4
+        uses: actions/setup-node@39370e3970a6d050c480ffad4ff0ed4d3fdee5af # v4
         with:
           node-version: "18"
 
@@ -256,7 +260,7 @@ jobs:
         run: |
           mkdir -p target/
           # Ignore any errors that occur while drafting release notes to not fail the build.
-          script/draft-release-notes "$version" "$channel" > target/release-notes.md || true
+          script/draft-release-notes "$RELEASE_VERSION" "$RELEASE_CHANNEL" > target/release-notes.md || true
 
       - name: Generate license file
         run: script/generate-licenses

.github/workflows/community_close_stale_issues.yml

@@ -24,7 +24,7 @@ jobs:
           # issues, preventing 365 days from working until then.
           days-before-stale: 180
           days-before-close: 7
-          any-of-issue-labels: "defect,panic / crash"
+          any-of-issue-labels: "bug,panic / crash"
           operations-per-run: 1000
           ascending: true
           enable-statistics: true

.github/workflows/community_update_all_top_ranking_issues.yml

@@ -12,7 +12,7 @@ jobs:
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
       - name: Set up uv
-        uses: astral-sh/setup-uv@f3bcaebff5eace81a1c062af9f9011aae482ca9d # v3
+        uses: astral-sh/setup-uv@2e657c127d5b1635d5a8e3fa40e0ac50a5bf6992 # v3
         with:
           version: "latest"
           enable-cache: true

.github/workflows/community_update_weekly_top_ranking_issues.yml

@@ -12,7 +12,7 @@ jobs:
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
       - name: Set up uv
-        uses: astral-sh/setup-uv@f3bcaebff5eace81a1c062af9f9011aae482ca9d # v3
+        uses: astral-sh/setup-uv@2e657c127d5b1635d5a8e3fa40e0ac50a5bf6992 # v3
         with:
           version: "latest"
           enable-cache: true

.github/workflows/danger.yml

@@ -21,7 +21,7 @@ jobs:
           version: 9
 
       - name: Setup Node
-        uses: actions/setup-node@0a44ba7841725637a19e28fa30b79a866c81b0a6 # v4
+        uses: actions/setup-node@39370e3970a6d050c480ffad4ff0ed4d3fdee5af # v4
         with:
           node-version: "20"
           cache: "pnpm"

.github/workflows/deploy_cloudflare.yml

@@ -37,28 +37,28 @@ jobs:
           mdbook build ./docs --dest-dir=../target/deploy/docs/
 
       - name: Deploy Docs
-        uses: cloudflare/wrangler-action@9681c2997648301493e78cacbfb790a9f19c833f # v3
+        uses: cloudflare/wrangler-action@05f17c4a695b4d94b57b59997562c6a4624c64e4 # v3
         with:
           apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
           accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
           command: pages deploy target/deploy --project-name=docs
 
       - name: Deploy Install
-        uses: cloudflare/wrangler-action@9681c2997648301493e78cacbfb790a9f19c833f # v3
+        uses: cloudflare/wrangler-action@05f17c4a695b4d94b57b59997562c6a4624c64e4 # v3
         with:
           apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
           accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
           command: r2 object put -f script/install.sh zed-open-source-website-assets/install.sh
 
       - name: Deploy Docs Workers
-        uses: cloudflare/wrangler-action@9681c2997648301493e78cacbfb790a9f19c833f # v3
+        uses: cloudflare/wrangler-action@05f17c4a695b4d94b57b59997562c6a4624c64e4 # v3
         with:
           apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
           accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
           command: deploy .cloudflare/docs-proxy/src/worker.js
 
       - name: Deploy Install Workers
-        uses: cloudflare/wrangler-action@9681c2997648301493e78cacbfb790a9f19c833f # v3
+        uses: cloudflare/wrangler-action@05f17c4a695b4d94b57b59997562c6a4624c64e4 # v3
         with:
           apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
           accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}

.github/workflows/randomized_tests.yml

@@ -22,7 +22,7 @@ jobs:
       - buildjet-16vcpu-ubuntu-2204
     steps:
       - name: Install Node
-        uses: actions/setup-node@0a44ba7841725637a19e28fa30b79a866c81b0a6 # v4
+        uses: actions/setup-node@39370e3970a6d050c480ffad4ff0ed4d3fdee5af # v4
         with:
           node-version: "18"
 

.github/workflows/release_nightly.yml

@@ -70,7 +70,7 @@ jobs:
       ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON: ${{ secrets.ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON }}
     steps:
       - name: Install Node
-        uses: actions/setup-node@0a44ba7841725637a19e28fa30b79a866c81b0a6 # v4
+        uses: actions/setup-node@39370e3970a6d050c480ffad4ff0ed4d3fdee5af # v4
         with:
           node-version: "18"
 

.mailmap

@@ -60,6 +60,8 @@ Max Brunsfeld <maxbrunsfeld@gmail.com>
 Max Brunsfeld <maxbrunsfeld@gmail.com> <max@zed.dev>
 Max Linke <maxlinke88@gmail.com>
 Max Linke <maxlinke88@gmail.com> <kain88-de@users.noreply.github.com>
+Michael Sloan <michael@zed.dev>
+Michael Sloan <michael@zed.dev> <mgsloan@google.com>
 Mikayla Maki <mikayla@zed.dev>
 Mikayla Maki <mikayla@zed.dev> <mikayla.c.maki@gmail.com>
 Mikayla Maki <mikayla@zed.dev> <mikayla.c.maki@icloud.com>

CODE_OF_CONDUCT.md

@@ -1,3 +1,3 @@
 # Code of Conduct
 
-The Code of Conduct for this repository can be found online at [zed.dev/docs/code-of-conduct](https://zed.dev/docs/code-of-conduct).
+The Code of Conduct for this repository can be found online at [zed.dev/code-of-conduct](https://zed.dev/code-of-conduct).

CONTRIBUTING.md

@@ -2,7 +2,7 @@
 
 Thanks for your interest in contributing to Zed, the collaborative platform that is also a code editor!
 
-All activity in Zed forums is subject to our [Code of Conduct](https://zed.dev/docs/code-of-conduct). Additionally, contributors must sign our [Contributor License Agreement](https://zed.dev/cla) before their contributions can be merged.
+All activity in Zed forums is subject to our [Code of Conduct](https://zed.dev/code-of-conduct). Additionally, contributors must sign our [Contributor License Agreement](https://zed.dev/cla) before their contributions can be merged.
 
 ## Contribution ideas
 

Cargo.toml

@@ -30,6 +30,7 @@ members = [
     "crates/extension",
     "crates/extension_api",
     "crates/extension_cli",
+    "crates/extension_host",
     "crates/extensions_ui",
     "crates/feature_flags",
     "crates/feedback",
@@ -117,6 +118,7 @@ members = [
     "crates/theme_selector",
     "crates/time_format",
     "crates/title_bar",
+    "crates/toolchain_selector",
     "crates/ui",
     "crates/ui_input",
     "crates/ui_macros",
@@ -137,7 +139,6 @@ members = [
     "extensions/astro",
     "extensions/clojure",
     "extensions/csharp",
-    "extensions/dart",
     "extensions/deno",
     "extensions/elixir",
     "extensions/elm",
@@ -202,6 +203,7 @@ db = { path = "crates/db" }
 diagnostics = { path = "crates/diagnostics" }
 editor = { path = "crates/editor" }
 extension = { path = "crates/extension" }
+extension_host = { path = "crates/extension_host" }
 extensions_ui = { path = "crates/extensions_ui" }
 feature_flags = { path = "crates/feature_flags" }
 feedback = { path = "crates/feedback" }
@@ -290,6 +292,7 @@ theme_importer = { path = "crates/theme_importer" }
 theme_selector = { path = "crates/theme_selector" }
 time_format = { path = "crates/time_format" }
 title_bar = { path = "crates/title_bar" }
+toolchain_selector = { path = "crates/toolchain_selector" }
 ui = { path = "crates/ui" }
 ui_input = { path = "crates/ui_input" }
 ui_macros = { path = "crates/ui_macros" }
@@ -369,6 +372,7 @@ linkify = "0.10.0"
 log = { version = "0.4.16", features = ["kv_unstable_serde", "serde"] }
 markup5ever_rcdom = "0.3.0"
 nanoid = "0.4"
+nbformat = "0.3.2"
 nix = "0.29"
 num-format = "0.4.4"
 once_cell = "1.19.0"
@@ -376,6 +380,12 @@ ordered-float = "2.1.1"
 palette = { version = "0.7.5", default-features = false, features = ["std"] }
 parking_lot = "0.12.1"
 pathdiff = "0.2"
+pet = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "ffcbf3f28c46633abd5448a52b1f396c322e0d6c" }
+pet-fs = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "ffcbf3f28c46633abd5448a52b1f396c322e0d6c" }
+pet-conda = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "ffcbf3f28c46633abd5448a52b1f396c322e0d6c"  }
+pet-core = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "ffcbf3f28c46633abd5448a52b1f396c322e0d6c"  }
+pet-poetry = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "ffcbf3f28c46633abd5448a52b1f396c322e0d6c"  }
+pet-reporter = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "ffcbf3f28c46633abd5448a52b1f396c322e0d6c"  }
 postage = { version = "0.5", features = ["futures-traits"] }
 pretty_assertions = "1.3.0"
 profiling = "1"
@@ -384,6 +394,7 @@ prost-build = "0.9"
 prost-types = "0.9"
 pulldown-cmark = { version = "0.12.0", default-features = false }
 rand = "0.8.5"
+rayon = "1.8"
 regex = "1.5"
 repair_json = "0.1.0"
 reqwest = { git = "https://github.com/zed-industries/reqwest.git", rev = "fd110f6998da16bbca97b6dddda9be7827c50e29", default-features = false, features = [
@@ -395,7 +406,7 @@ reqwest = { git = "https://github.com/zed-industries/reqwest.git", rev = "fd110f
     "stream",
 ] }
 rsa = "0.9.6"
-runtimelib = { version = "0.15", default-features = false, features = [
+runtimelib = { version = "0.16.1", default-features = false, features = [
     "async-dispatcher-runtime",
 ] }
 rustc-demangle = "0.1.23"
@@ -465,6 +476,7 @@ tree-sitter-yaml = { git = "https://github.com/zed-industries/tree-sitter-yaml",
 unicase = "2.6"
 unindent = "0.1.7"
 unicode-segmentation = "1.10"
+unicode-script = "0.5.7"
 url = "2.2"
 uuid = { version = "1.1.2", features = ["v4", "v5", "serde"] }
 wasmparser = "0.215"

assets/icons/file_icons/file_types.json

@@ -58,6 +58,7 @@
     "gitignore": "vcs",
     "gitkeep": "vcs",
     "gitmodules": "vcs",
+    "gleam": "gleam",
     "go": "go",
     "gql": "graphql",
     "graphql": "graphql",
@@ -83,6 +84,7 @@
     "j2k": "image",
     "java": "java",
     "jfif": "image",
+    "jl": "julia",
     "jp2": "image",
     "jpeg": "image",
     "jpg": "image",
@@ -90,7 +92,6 @@
     "json": "storage",
     "jsonc": "storage",
     "jsx": "react",
-    "julia": "julia",
     "jxl": "image",
     "kt": "kotlin",
     "ldf": "storage",
@@ -264,6 +265,9 @@
     "fsharp": {
       "icon": "icons/file_icons/fsharp.svg"
     },
+    "gleam": {
+      "icon": "icons/file_icons/gleam.svg"
+    },
     "go": {
       "icon": "icons/file_icons/go.svg"
     },

assets/icons/file_icons/gleam.svg

@@ -0,0 +1,7 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M7.3848 9.30444C7.3848 9.30444 7.53254 10.2646 8.53248 10.0882C9.53242 9.91193 9.36378 8.95549 9.36378 8.95549" stroke="black" stroke-width="1.25" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M5.54155 5.54157C6.12355 4.90104 6.01688 2.62541 7.22875 2.3985C8.44063 2.17158 9.19097 4.33148 9.91982 4.6814C10.6487 5.03133 12.8517 4.3028 13.4381 5.38734C14.0244 6.47188 12.1395 7.95973 12.026 8.64088C11.9126 9.32203 13.3614 11.2416 12.4675 12.1701C11.5736 13.0986 9.73005 11.7545 8.90486 11.8834C8.07966 12.0123 6.79244 13.9095 5.67367 13.3502C4.55491 12.7909 5.16702 10.5455 4.82437 9.87612C4.48171 9.20673 2.34028 8.54978 2.4525 7.35049C2.56471 6.15121 4.95956 6.1821 5.54155 5.54157Z" stroke="#FF7676" stroke-opacity="0.52" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M5.54155 5.54157C6.12355 4.90104 6.01688 2.62541 7.22875 2.3985C8.44063 2.17158 9.19097 4.33148 9.91982 4.6814C10.6487 5.03133 12.8517 4.3028 13.4381 5.38734C14.0244 6.47188 12.1395 7.95973 12.026 8.64088C11.9126 9.32203 13.3614 11.2416 12.4675 12.1701C11.5736 13.0986 9.73005 11.7545 8.90486 11.8834C8.07966 12.0123 6.79244 13.9095 5.67367 13.3502C4.55491 12.7909 5.16702 10.5455 4.82437 9.87612C4.48171 9.20673 2.34028 8.54978 2.4525 7.35049C2.56471 6.15121 4.95956 6.1821 5.54155 5.54157Z" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+<circle cx="6.25098" cy="7.75" r="0.75" fill="black"/>
+<circle cx="10.1035" cy="7.25" r="0.75" fill="black"/>
+</svg>

assets/icons/file_search.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-file-search"><path d="M14 2v4a2 2 0 0 0 2 2h4"/><path d="M4.268 21a2 2 0 0 0 1.727 1H18a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v3"/><path d="m9 18-1.5-1.5"/><circle cx="5" cy="14" r="3"/></svg>

assets/icons/list_x.svg

@@ -0,0 +1,7 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M8.33333 8H3" stroke="#FBF1C7" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M11.6667 4H3" stroke="#FBF1C7" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M11.6667 12H3" stroke="#FBF1C7" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M13.6667 6.66663L11 9.33329" stroke="#FBF1C7" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M11 6.66663L13.6667 9.33329" stroke="#FBF1C7" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

assets/icons/refresh_title.svg

@@ -0,0 +1,5 @@
+<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M7 21V12M7 12H3M7 12H11" stroke="black" stroke-width="2" stroke-linecap="round"/>
+<path d="M21 19L16 19L16 14" stroke="black" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M7.99987 5.07027L7.49915 4.20467L7.99987 5.07027ZM6.04652 5.25026C5.63245 5.61573 5.59305 6.24766 5.95851 6.66173C6.32398 7.0758 6.95592 7.1152 7.36999 6.74974L6.04652 5.25026ZM11.9999 5C15.8659 5 18.9999 8.13401 18.9999 12H20.9999C20.9999 7.02944 16.9705 3 11.9999 3V5ZM18.9999 12C18.9999 14.2101 17.9768 16.1806 16.3744 17.4651L17.6254 19.0256C19.6809 17.3779 20.9999 14.8426 20.9999 12H18.9999ZM8.5006 5.93588C9.5292 5.34086 10.7232 5 11.9999 5V3C10.3623 3 8.82395 3.4383 7.49915 4.20467L8.5006 5.93588ZM7.36999 6.74974C7.71803 6.44255 8.09667 6.16954 8.5006 5.93588L7.49915 4.20467C6.9797 4.50515 6.49329 4.85593 6.04652 5.25026L7.36999 6.74974Z" fill="black"/>
+</svg>

assets/icons/wand.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-wand"><path d="M15 4V2"/><path d="M15 16v-2"/><path d="M8 9h2"/><path d="M20 9h2"/><path d="M17.8 11.8 19 13"/><path d="M15 9h.01"/><path d="M17.8 6.2 19 5"/><path d="m3 21 9-9"/><path d="M12.2 6.2 11 5"/></svg>

assets/keymaps/default-linux.json

@@ -251,10 +251,10 @@
       "ctrl-shift-pagedown": "pane::SwapItemRight",
       "ctrl-w": "pane::CloseActiveItem",
       "ctrl-f4": "pane::CloseActiveItem",
-      "alt-ctrl-t": "pane::CloseInactiveItems",
+      "alt-ctrl-t": ["pane::CloseInactiveItems", { "close_pinned": false }],
       "alt-ctrl-shift-w": "workspace::CloseInactiveTabsAndPanes",
-      "ctrl-k u": "pane::CloseCleanItems",
-      "ctrl-k w": "pane::CloseAllItems",
+      "ctrl-k u": ["pane::CloseCleanItems", { "close_pinned": false }],
+      "ctrl-k w": ["pane::CloseAllItems", { "close_pinned": false }],
       "ctrl-shift-f": "project_search::ToggleFocus",
       "ctrl-alt-g": "search::SelectNextMatch",
       "ctrl-alt-shift-g": "search::SelectPrevMatch",
@@ -532,6 +532,7 @@
     "context": "ContextEditor > Editor",
     "bindings": {
       "ctrl-enter": "assistant::Assist",
+      "ctrl-shift-enter": "assistant::Edit",
       "ctrl-s": "workspace::Save",
       "ctrl->": "assistant::QuoteSelection",
       "ctrl-<": "assistant::InsertIntoEditor",

assets/keymaps/default-macos.json

@@ -201,6 +201,7 @@
     "context": "ContextEditor > Editor",
     "bindings": {
       "cmd-enter": "assistant::Assist",
+      "cmd-shift-enter": "assistant::Edit",
       "cmd-s": "workspace::Save",
       "cmd->": "assistant::QuoteSelection",
       "cmd-<": "assistant::InsertIntoEditor",
@@ -290,10 +291,10 @@
       "ctrl-shift-pageup": "pane::SwapItemLeft",
       "ctrl-shift-pagedown": "pane::SwapItemRight",
       "cmd-w": "pane::CloseActiveItem",
-      "alt-cmd-t": "pane::CloseInactiveItems",
+      "alt-cmd-t": ["pane::CloseInactiveItems", { "close_pinned": false }],
       "ctrl-alt-cmd-w": "workspace::CloseInactiveTabsAndPanes",
-      "cmd-k u": "pane::CloseCleanItems",
-      "cmd-k cmd-w": "pane::CloseAllItems",
+      "cmd-k u": ["pane::CloseCleanItems", { "close_pinned": false }],
+      "cmd-k cmd-w": ["pane::CloseAllItems", { "close_pinned": false }],
       "cmd-f": "project_search::ToggleFocus",
       "cmd-g": "search::SelectNextMatch",
       "cmd-shift-g": "search::SelectPrevMatch",
@@ -349,6 +350,7 @@
       "alt-cmd-]": "editor::UnfoldLines",
       "cmd-k cmd-l": "editor::ToggleFold",
       "cmd-k cmd-[": "editor::FoldRecursive",
+      "cmd-k cmd-]": "editor::UnfoldRecursive",
       "cmd-k cmd-1": ["editor::FoldAtLevel", { "level": 1 }],
       "cmd-k cmd-2": ["editor::FoldAtLevel", { "level": 2 }],
       "cmd-k cmd-3": ["editor::FoldAtLevel", { "level": 3 }],

assets/keymaps/linux/jetbrains.json

@@ -25,8 +25,8 @@
       "alt-j": ["editor::SelectNext", { "replace_newest": false }],
       "alt-shift-j": ["editor::SelectPrevious", { "replace_newest": false }],
       "ctrl-/": ["editor::ToggleComments", { "advance_downwards": true }],
-      "alt-up": "editor::SelectLargerSyntaxNode",
-      "alt-down": "editor::SelectSmallerSyntaxNode",
+      "ctrl-w": "editor::SelectLargerSyntaxNode",
+      "ctrl-shift-w": "editor::SelectSmallerSyntaxNode",
       "shift-alt-up": "editor::MoveLineUp",
       "shift-alt-down": "editor::MoveLineDown",
       "ctrl-alt-l": "editor::Format",

assets/keymaps/macos/jetbrains.json

@@ -24,8 +24,8 @@
       "ctrl-g": ["editor::SelectNext", { "replace_newest": false }],
       "ctrl-cmd-g": ["editor::SelectPrevious", { "replace_newest": false }],
       "cmd-/": ["editor::ToggleComments", { "advance_downwards": true }],
-      "alt-up": "editor::SelectLargerSyntaxNode",
-      "alt-down": "editor::SelectSmallerSyntaxNode",
+      "cmd-up": "editor::SelectLargerSyntaxNode",
+      "cmd-down": "editor::SelectSmallerSyntaxNode",
       "shift-alt-up": "editor::MoveLineUp",
       "shift-alt-down": "editor::MoveLineDown",
       "cmd-alt-l": "editor::Format",
@@ -58,6 +58,12 @@
       "alt-enter": "editor::ToggleCodeActions"
     }
   },
+  {
+    "context": "BufferSearchBar > Editor",
+    "bindings": {
+      "shift-enter": "search::SelectPrevMatch"
+    }
+  },
   {
     "context": "Workspace",
     "bindings": {

assets/keymaps/vim.json

@@ -127,6 +127,9 @@
       "shift-h": "vim::WindowTop",
       "shift-m": "vim::WindowMiddle",
       "shift-l": "vim::WindowBottom",
+      "q": "vim::ToggleRecord",
+      "shift-q": "vim::ReplayLastRecording",
+      "@": ["vim::PushOperator", "ReplayRegister"],
       // z commands
       "z enter": ["workspace::SendKeystrokes", "z t ^"],
       "z -": ["workspace::SendKeystrokes", "z b ^"],
@@ -137,14 +140,14 @@
       "z .": ["workspace::SendKeystrokes", "z z ^"],
       "z b": "editor::ScrollCursorBottom",
       "z a": "editor::ToggleFold",
-      "z A": "editor::ToggleFoldRecursive",
+      "z shift-a": "editor::ToggleFoldRecursive",
       "z c": "editor::Fold",
-      "z C": "editor::FoldRecursive",
+      "z shift-c": "editor::FoldRecursive",
       "z o": "editor::UnfoldLines",
-      "z O": "editor::UnfoldRecursive",
+      "z shift-o": "editor::UnfoldRecursive",
       "z f": "editor::FoldSelectedRanges",
-      "z M": "editor::FoldAll",
-      "z R": "editor::UnfoldAll",
+      "z shift-m": "editor::FoldAll",
+      "z shift-r": "editor::UnfoldAll",
       "shift-z shift-q": ["pane::CloseActiveItem", { "saveIntent": "skip" }],
       "shift-z shift-z": ["pane::CloseActiveItem", { "saveIntent": "saveAll" }],
       // Count support
@@ -157,51 +160,6 @@
       "7": ["vim::Number", 7],
       "8": ["vim::Number", 8],
       "9": ["vim::Number", 9],
-      // window related commands (ctrl-w X)
-      "ctrl-w": null,
-      "ctrl-w left": ["workspace::ActivatePaneInDirection", "Left"],
-      "ctrl-w right": ["workspace::ActivatePaneInDirection", "Right"],
-      "ctrl-w up": ["workspace::ActivatePaneInDirection", "Up"],
-      "ctrl-w down": ["workspace::ActivatePaneInDirection", "Down"],
-      "ctrl-w h": ["workspace::ActivatePaneInDirection", "Left"],
-      "ctrl-w l": ["workspace::ActivatePaneInDirection", "Right"],
-      "ctrl-w k": ["workspace::ActivatePaneInDirection", "Up"],
-      "ctrl-w j": ["workspace::ActivatePaneInDirection", "Down"],
-      "ctrl-w ctrl-h": ["workspace::ActivatePaneInDirection", "Left"],
-      "ctrl-w ctrl-l": ["workspace::ActivatePaneInDirection", "Right"],
-      "ctrl-w ctrl-k": ["workspace::ActivatePaneInDirection", "Up"],
-      "ctrl-w ctrl-j": ["workspace::ActivatePaneInDirection", "Down"],
-      "ctrl-w shift-left": ["workspace::SwapPaneInDirection", "Left"],
-      "ctrl-w shift-right": ["workspace::SwapPaneInDirection", "Right"],
-      "ctrl-w shift-up": ["workspace::SwapPaneInDirection", "Up"],
-      "ctrl-w shift-down": ["workspace::SwapPaneInDirection", "Down"],
-      "ctrl-w shift-h": ["workspace::SwapPaneInDirection", "Left"],
-      "ctrl-w shift-l": ["workspace::SwapPaneInDirection", "Right"],
-      "ctrl-w shift-k": ["workspace::SwapPaneInDirection", "Up"],
-      "ctrl-w shift-j": ["workspace::SwapPaneInDirection", "Down"],
-      "ctrl-w g t": "pane::ActivateNextItem",
-      "ctrl-w ctrl-g t": "pane::ActivateNextItem",
-      "ctrl-w g shift-t": "pane::ActivatePrevItem",
-      "ctrl-w ctrl-g shift-t": "pane::ActivatePrevItem",
-      "ctrl-w w": "workspace::ActivateNextPane",
-      "ctrl-w ctrl-w": "workspace::ActivateNextPane",
-      "ctrl-w p": "workspace::ActivatePreviousPane",
-      "ctrl-w ctrl-p": "workspace::ActivatePreviousPane",
-      "ctrl-w shift-w": "workspace::ActivatePreviousPane",
-      "ctrl-w ctrl-shift-w": "workspace::ActivatePreviousPane",
-      "ctrl-w v": "pane::SplitVertical",
-      "ctrl-w ctrl-v": "pane::SplitVertical",
-      "ctrl-w s": "pane::SplitHorizontal",
-      "ctrl-w shift-s": "pane::SplitHorizontal",
-      "ctrl-w ctrl-s": "pane::SplitHorizontal",
-      "ctrl-w c": "pane::CloseAllItems",
-      "ctrl-w ctrl-c": "pane::CloseAllItems",
-      "ctrl-w q": "pane::CloseAllItems",
-      "ctrl-w ctrl-q": "pane::CloseAllItems",
-      "ctrl-w o": "workspace::CloseInactiveTabsAndPanes",
-      "ctrl-w ctrl-o": "workspace::CloseInactiveTabsAndPanes",
-      "ctrl-w n": "workspace::NewFileSplitHorizontal",
-      "ctrl-w ctrl-n": "workspace::NewFileSplitHorizontal",
       "ctrl-w d": "editor::GoToDefinitionSplit",
       "ctrl-w g d": "editor::GoToDefinitionSplit",
       "ctrl-w shift-d": "editor::GoToTypeDefinitionSplit",
@@ -251,9 +209,6 @@
       "\"": ["vim::PushOperator", "Register"],
       "g q": ["vim::PushOperator", "Rewrap"],
       "g w": ["vim::PushOperator", "Rewrap"],
-      "q": "vim::ToggleRecord",
-      "shift-q": "vim::ReplayLastRecording",
-      "@": ["vim::PushOperator", "ReplayRegister"],
       "ctrl-pagedown": "pane::ActivateNextItem",
       "ctrl-pageup": "pane::ActivatePrevItem",
       "insert": "vim::InsertBefore",
@@ -279,7 +234,7 @@
     "bindings": {
       ":": "vim::VisualCommand",
       "u": "vim::ConvertToLowerCase",
-      "U": "vim::ConvertToUpperCase",
+      "shift-u": "vim::ConvertToUpperCase",
       "o": "vim::OtherEnd",
       "shift-o": "vim::OtherEnd",
       "d": "vim::VisualDelete",
@@ -303,8 +258,8 @@
       "g ctrl-x": ["vim::Decrement", { "step": true }],
       "shift-i": "vim::InsertBefore",
       "shift-a": "vim::InsertAfter",
-      "g I": "vim::VisualInsertFirstNonWhiteSpace",
-      "g A": "vim::VisualInsertEndOfLine",
+      "g shift-i": "vim::VisualInsertFirstNonWhiteSpace",
+      "g shift-a": "vim::VisualInsertEndOfLine",
       "shift-j": "vim::JoinLines",
       "r": ["vim::PushOperator", "Replace"],
       "ctrl-c": ["vim::SwitchMode", "Normal"],
@@ -339,6 +294,10 @@
       "ctrl-t": "vim::Indent",
       "ctrl-d": "vim::Outdent",
       "ctrl-k": ["vim::PushOperator", { "Digraph": {} }],
+      "ctrl-v": ["vim::PushOperator", { "Literal": {} }],
+      "ctrl-shift-v": "editor::Paste", // note: this is *very* similar to ctrl-v in vim, but ctrl-shift-v on linux is the typical shortcut for paste when ctrl-v is already in use.
+      "ctrl-q": ["vim::PushOperator", { "Literal": {} }],
+      "ctrl-shift-q": ["vim::PushOperator", { "Literal": {} }],
       "ctrl-r": ["vim::PushOperator", "Register"],
       "insert": "vim::ToggleReplace"
     }
@@ -357,6 +316,10 @@
       "ctrl-c": "vim::NormalBefore",
       "ctrl-[": "vim::NormalBefore",
       "ctrl-k": ["vim::PushOperator", { "Digraph": {} }],
+      "ctrl-v": ["vim::PushOperator", { "Literal": {} }],
+      "ctrl-shift-v": "editor::Paste", // note: this is *very* similar to ctrl-v in vim, but ctrl-shift-v on linux is the typical shortcut for paste when ctrl-v is already in use.
+      "ctrl-q": ["vim::PushOperator", { "Literal": {} }],
+      "ctrl-shift-q": ["vim::PushOperator", { "Literal": {} }],
       "backspace": "vim::UndoReplace",
       "tab": "vim::Tab",
       "enter": "vim::Enter",
@@ -371,7 +334,9 @@
       "escape": "vim::ClearOperators",
       "ctrl-c": "vim::ClearOperators",
       "ctrl-[": "vim::ClearOperators",
-      "ctrl-k": ["vim::PushOperator", { "Digraph": {} }]
+      "ctrl-k": ["vim::PushOperator", { "Digraph": {} }],
+      "ctrl-v": ["vim::PushOperator", { "Literal": {} }],
+      "ctrl-q": ["vim::PushOperator", { "Literal": {} }]
     }
   },
   {
@@ -399,12 +364,14 @@
       "b": "vim::Parentheses",
       "[": "vim::SquareBrackets",
       "]": "vim::SquareBrackets",
+      "r": "vim::SquareBrackets",
       "{": "vim::CurlyBrackets",
       "}": "vim::CurlyBrackets",
       "shift-b": "vim::CurlyBrackets",
       "<": "vim::AngleBrackets",
       ">": "vim::AngleBrackets",
-      "a": "vim::Argument"
+      "a": "vim::AngleBrackets",
+      "g": "vim::Argument"
     }
   },
   {
@@ -485,6 +452,49 @@
       "c": "vim::CurrentLine"
     }
   },
+  {
+    "context": "vim_mode == literal",
+    "bindings": {
+      "ctrl-@": ["vim::Literal", ["ctrl-@", "\u0000"]],
+      "ctrl-a": ["vim::Literal", ["ctrl-a", "\u0001"]],
+      "ctrl-b": ["vim::Literal", ["ctrl-b", "\u0002"]],
+      "ctrl-c": ["vim::Literal", ["ctrl-c", "\u0003"]],
+      "ctrl-d": ["vim::Literal", ["ctrl-d", "\u0004"]],
+      "ctrl-e": ["vim::Literal", ["ctrl-e", "\u0005"]],
+      "ctrl-f": ["vim::Literal", ["ctrl-f", "\u0006"]],
+      "ctrl-g": ["vim::Literal", ["ctrl-g", "\u0007"]],
+      "ctrl-h": ["vim::Literal", ["ctrl-h", "\u0008"]],
+      "ctrl-i": ["vim::Literal", ["ctrl-i", "\u0009"]],
+      "ctrl-j": ["vim::Literal", ["ctrl-j", "\u000A"]],
+      "ctrl-k": ["vim::Literal", ["ctrl-k", "\u000B"]],
+      "ctrl-l": ["vim::Literal", ["ctrl-l", "\u000C"]],
+      "ctrl-m": ["vim::Literal", ["ctrl-m", "\u000D"]],
+      "ctrl-n": ["vim::Literal", ["ctrl-n", "\u000E"]],
+      "ctrl-o": ["vim::Literal", ["ctrl-o", "\u000F"]],
+      "ctrl-p": ["vim::Literal", ["ctrl-p", "\u0010"]],
+      "ctrl-q": ["vim::Literal", ["ctrl-q", "\u0011"]],
+      "ctrl-r": ["vim::Literal", ["ctrl-r", "\u0012"]],
+      "ctrl-s": ["vim::Literal", ["ctrl-s", "\u0013"]],
+      "ctrl-t": ["vim::Literal", ["ctrl-t", "\u0014"]],
+      "ctrl-u": ["vim::Literal", ["ctrl-u", "\u0015"]],
+      "ctrl-v": ["vim::Literal", ["ctrl-v", "\u0016"]],
+      "ctrl-w": ["vim::Literal", ["ctrl-w", "\u0017"]],
+      "ctrl-x": ["vim::Literal", ["ctrl-x", "\u0018"]],
+      "ctrl-y": ["vim::Literal", ["ctrl-y", "\u0019"]],
+      "ctrl-z": ["vim::Literal", ["ctrl-z", "\u001A"]],
+      "ctrl-[": ["vim::Literal", ["ctrl-[", "\u001B"]],
+      "ctrl-\\": ["vim::Literal", ["ctrl-\\", "\u001C"]],
+      "ctrl-]": ["vim::Literal", ["ctrl-]", "\u001D"]],
+      "ctrl-^": ["vim::Literal", ["ctrl-^", "\u001E"]],
+      "ctrl-_": ["vim::Literal", ["ctrl-_", "\u001F"]],
+      "escape": ["vim::Literal", ["escape", "\u001B"]],
+      "enter": ["vim::Literal", ["enter", "\u000D"]],
+      "tab": ["vim::Literal", ["tab", "\u0009"]],
+      // zed extensions:
+      "backspace": ["vim::Literal", ["backspace", "\u0008"]],
+      "delete": ["vim::Literal", ["delete", "\u007F"]]
+    }
+  },
   {
     "context": "BufferSearchBar && !in_replace",
     "bindings": {
@@ -493,7 +503,57 @@
     }
   },
   {
-    "context": "EmptyPane || SharedScreen",
+    "context": "ProjectPanel || CollabPanel || OutlinePanel || ChatPanel || VimControl || EmptyPane || SharedScreen || MarkdownPreview || KeyContextView",
+    "bindings": {
+      // window related commands (ctrl-w X)
+      "ctrl-w": null,
+      "ctrl-w left": ["workspace::ActivatePaneInDirection", "Left"],
+      "ctrl-w right": ["workspace::ActivatePaneInDirection", "Right"],
+      "ctrl-w up": ["workspace::ActivatePaneInDirection", "Up"],
+      "ctrl-w down": ["workspace::ActivatePaneInDirection", "Down"],
+      "ctrl-w h": ["workspace::ActivatePaneInDirection", "Left"],
+      "ctrl-w l": ["workspace::ActivatePaneInDirection", "Right"],
+      "ctrl-w k": ["workspace::ActivatePaneInDirection", "Up"],
+      "ctrl-w j": ["workspace::ActivatePaneInDirection", "Down"],
+      "ctrl-w ctrl-h": ["workspace::ActivatePaneInDirection", "Left"],
+      "ctrl-w ctrl-l": ["workspace::ActivatePaneInDirection", "Right"],
+      "ctrl-w ctrl-k": ["workspace::ActivatePaneInDirection", "Up"],
+      "ctrl-w ctrl-j": ["workspace::ActivatePaneInDirection", "Down"],
+      "ctrl-w shift-left": ["workspace::SwapPaneInDirection", "Left"],
+      "ctrl-w shift-right": ["workspace::SwapPaneInDirection", "Right"],
+      "ctrl-w shift-up": ["workspace::SwapPaneInDirection", "Up"],
+      "ctrl-w shift-down": ["workspace::SwapPaneInDirection", "Down"],
+      "ctrl-w shift-h": ["workspace::SwapPaneInDirection", "Left"],
+      "ctrl-w shift-l": ["workspace::SwapPaneInDirection", "Right"],
+      "ctrl-w shift-k": ["workspace::SwapPaneInDirection", "Up"],
+      "ctrl-w shift-j": ["workspace::SwapPaneInDirection", "Down"],
+      "ctrl-w g t": "pane::ActivateNextItem",
+      "ctrl-w ctrl-g t": "pane::ActivateNextItem",
+      "ctrl-w g shift-t": "pane::ActivatePrevItem",
+      "ctrl-w ctrl-g shift-t": "pane::ActivatePrevItem",
+      "ctrl-w w": "workspace::ActivateNextPane",
+      "ctrl-w ctrl-w": "workspace::ActivateNextPane",
+      "ctrl-w p": "workspace::ActivatePreviousPane",
+      "ctrl-w ctrl-p": "workspace::ActivatePreviousPane",
+      "ctrl-w shift-w": "workspace::ActivatePreviousPane",
+      "ctrl-w ctrl-shift-w": "workspace::ActivatePreviousPane",
+      "ctrl-w v": "pane::SplitVertical",
+      "ctrl-w ctrl-v": "pane::SplitVertical",
+      "ctrl-w s": "pane::SplitHorizontal",
+      "ctrl-w shift-s": "pane::SplitHorizontal",
+      "ctrl-w ctrl-s": "pane::SplitHorizontal",
+      "ctrl-w c": "pane::CloseAllItems",
+      "ctrl-w ctrl-c": "pane::CloseAllItems",
+      "ctrl-w q": "pane::CloseAllItems",
+      "ctrl-w ctrl-q": "pane::CloseAllItems",
+      "ctrl-w o": "workspace::CloseInactiveTabsAndPanes",
+      "ctrl-w ctrl-o": "workspace::CloseInactiveTabsAndPanes",
+      "ctrl-w n": "workspace::NewFileSplitHorizontal",
+      "ctrl-w ctrl-n": "workspace::NewFileSplitHorizontal"
+    }
+  },
+  {
+    "context": "EmptyPane || SharedScreen || MarkdownPreview || KeyContextView",
     "bindings": {
       ":": "command_palette::Toggle",
       "g /": "pane::DeploySearch"

assets/settings/default.json

@@ -68,9 +68,17 @@
   "ui_font_size": 16,
   // How much to fade out unused code.
   "unnecessary_code_fade": 0.3,
-  // The factor to grow the active pane by. Defaults to 1.0
-  // which gives the same size as all other panes.
-  "active_pane_magnification": 1.0,
+  // Active pane styling settings.
+  "active_pane_modifiers": {
+    // The factor to grow the active pane by. Defaults to 1.0
+    // which gives the same size as all other panes.
+    "magnification": 1.0,
+    // Inset border size of the active pane, in pixels.
+    "border_size": 0.0,
+    // Opacity of the inactive panes. 0 means transparent, 1 means opaque.
+    // Values are clamped to the [0.0, 1.0] range.
+    "inactive_opacity": 1.0
+  },
   // The direction that you want to split panes horizontally. Defaults to "up"
   "pane_split_direction_horizontal": "up",
   // The direction that you want to split panes horizontally. Defaults to "left"
@@ -152,7 +160,7 @@
   "show_signature_help_after_edits": true,
   // Whether to show wrap guides (vertical rulers) in the editor.
   // Setting this to true will show a guide at the 'preferred_line_length' value
-  // if softwrap is set to 'preferred_line_length', and will show any
+  // if 'soft_wrap' is set to 'preferred_line_length', and will show any
   // additional guides as specified by the 'wrap_guides' setting.
   "show_wrap_guides": true,
   // Character counts at which to show wrap guides in the editor.
@@ -174,6 +182,8 @@
   // bracket, brace, single or double quote characters.
   // For example, when you select text and type (, Zed will surround the text with ().
   "use_auto_surround": true,
+  // Whether indentation of pasted content should be adjusted based on the context.
+  "auto_indent_on_paste": true,
   // Controls how the editor handles the autoclosed characters.
   // When set to `false`(default), skipping over and auto-removing of the closing characters
   // happen only for auto-inserted characters.
@@ -346,8 +356,6 @@
     "git_status": true,
     // Amount of indentation for nested items.
     "indent_size": 20,
-    // Whether to show indent guides in the project panel.
-    "indent_guides": true,
     // Whether to reveal it in the project panel automatically,
     // when a corresponding project entry becomes active.
     // Gitignored entries are never auto revealed.
@@ -371,6 +379,17 @@
       /// 5. Never show the scrollbar:
       ///    "never"
       "show": null
+    },
+    // Settings related to indent guides in the project panel.
+    "indent_guides": {
+      // When to show indent guides in the project panel.
+      // This setting can take two values:
+      //
+      // 1. Always show indent guides:
+      //    "always"
+      // 2. Never show indent guides:
+      //    "never"
+      "show": "always"
     }
   },
   "outline_panel": {
@@ -388,15 +407,41 @@
     "git_status": true,
     // Amount of indentation for nested items.
     "indent_size": 20,
-    // Whether to show indent guides in the outline panel.
-    "indent_guides": true,
     // Whether to reveal it in the outline panel automatically,
     // when a corresponding outline entry becomes active.
     // Gitignored entries are never auto revealed.
     "auto_reveal_entries": true,
     /// Whether to fold directories automatically
     /// when a directory has only one directory inside.
-    "auto_fold_dirs": true
+    "auto_fold_dirs": true,
+    // Settings related to indent guides in the outline panel.
+    "indent_guides": {
+      // When to show indent guides in the outline panel.
+      // This setting can take two values:
+      //
+      // 1. Always show indent guides:
+      //    "always"
+      // 2. Never show indent guides:
+      //    "never"
+      "show": "always"
+    },
+    /// Scrollbar-related settings
+    "scrollbar": {
+      /// When to show the scrollbar in the project panel.
+      /// This setting can take four values:
+      ///
+      /// 1. null (default): Inherit editor settings
+      /// 2. Show the scrollbar if there's important information or
+      ///    follow the system's configured behavior (default):
+      ///   "auto"
+      /// 3. Match the system's configured behavior:
+      ///    "system"
+      /// 4. Always show the scrollbar:
+      ///    "always"
+      /// 5. Never show the scrollbar:
+      ///    "never"
+      "show": null
+    }
   },
   "collaboration_panel": {
     // Whether to show the collaboration panel button in the status bar.
@@ -440,7 +485,7 @@
     "default_width": 640,
     // Default height when the assistant is docked to the bottom.
     "default_height": 320,
-    // The default model to use when creating new contexts.
+    // The default model to use when creating new chats.
     "default_model": {
       // The provider to use.
       "provider": "zed.dev",
@@ -617,6 +662,12 @@
       // Sets a delay after which the inline blame information is shown.
       // Delay is restarted with every cursor movement.
       // "delay_ms": 600
+      //
+      // Whether or not do display the git commit summary on the same line.
+      // "show_commit_summary": false
+      //
+      // The minimum column number to show the inline blame information at
+      // "min_column": 0
     }
   },
   // Configuration for how direnv configuration should be loaded. May take 2 values:

assets/settings/initial_tasks.json

@@ -16,6 +16,7 @@
     "allow_concurrent_runs": false,
     // What to do with the terminal pane and tab, after the command was started:
     // * `always` — always show the terminal pane, add and focus the corresponding task's tab in it (default)
+    // * `no_focus` — always show the terminal pane, add/reuse the task's tab there, but don't focus it
     // * `never` — avoid changing current terminal pane focus, but still add/reuse the task's tab there
     "reveal": "always",
     // What to do with the terminal pane and tab, after the command had finished:

assets/themes/one/one.json

@@ -27,15 +27,15 @@
         "ghost_element.active": "#454a56ff",
         "ghost_element.selected": "#454a56ff",
         "ghost_element.disabled": "#2e343eff",
-        "text": "#c8ccd4ff",
-        "text.muted": "#838994ff",
-        "text.placeholder": "#696B77ff",
-        "text.disabled": "#696B77ff",
+        "text": "#dce0e5ff",
+        "text.muted": "#a9afbcff",
+        "text.placeholder": "#878a98ff",
+        "text.disabled": "#878a98ff",
         "text.accent": "#74ade8ff",
-        "icon": "#c8ccd4ff",
-        "icon.muted": "#838994ff",
-        "icon.disabled": "#696B77ff",
-        "icon.placeholder": "#838994ff",
+        "icon": "#dce0e5ff",
+        "icon.muted": "#a9afbcff",
+        "icon.disabled": "#878a98ff",
+        "icon.placeholder": "#a9afbcff",
         "icon.accent": "#74ade8ff",
         "status_bar.background": "#3b414dff",
         "title_bar.background": "#3b414dff",
@@ -60,19 +60,19 @@
         "editor.active_line.background": "#2f343ebf",
         "editor.highlighted_line.background": "#2f343eff",
         "editor.line_number": "#c8ccd459",
-        "editor.active_line_number": "#c8ccd4ff",
-        "editor.invisible": "#696B77ff",
+        "editor.active_line_number": "#dce0e5ff",
+        "editor.invisible": "#878a98ff",
         "editor.wrap_guide": "#c8ccd40d",
         "editor.active_wrap_guide": "#c8ccd41a",
         "editor.document_highlight.read_background": "#74ade81a",
         "editor.document_highlight.write_background": "#555a6366",
         "terminal.background": "#282c33ff",
-        "terminal.foreground": "#c8ccd4ff",
-        "terminal.bright_foreground": "#c8ccd4ff",
+        "terminal.foreground": "#dce0e5ff",
+        "terminal.bright_foreground": "#dce0e5ff",
         "terminal.dim_foreground": "#282c33ff",
         "terminal.ansi.black": "#282c33ff",
         "terminal.ansi.bright_black": "#525561ff",
-        "terminal.ansi.dim_black": "#c8ccd4ff",
+        "terminal.ansi.dim_black": "#dce0e5ff",
         "terminal.ansi.red": "#d07277ff",
         "terminal.ansi.bright_red": "#673a3cff",
         "terminal.ansi.dim_red": "#eab7b9ff",
@@ -91,8 +91,8 @@
         "terminal.ansi.cyan": "#6eb4bfff",
         "terminal.ansi.bright_cyan": "#3a565bff",
         "terminal.ansi.dim_cyan": "#b9d9dfff",
-        "terminal.ansi.white": "#c8ccd4ff",
-        "terminal.ansi.bright_white": "#c8ccd4ff",
+        "terminal.ansi.white": "#dce0e5ff",
+        "terminal.ansi.bright_white": "#dce0e5ff",
         "terminal.ansi.dim_white": "#575d65ff",
         "link_text.hover": "#74ade8ff",
         "conflict": "#dec184ff",
@@ -107,14 +107,14 @@
         "error": "#d07277ff",
         "error.background": "#d072771a",
         "error.border": "#4c2b2cff",
-        "hidden": "#696B77ff",
-        "hidden.background": "#696B771a",
+        "hidden": "#878a98ff",
+        "hidden.background": "#696b771a",
         "hidden.border": "#414754ff",
-        "hint": "#5a6f89ff",
+        "hint": "#788ca6ff",
         "hint.background": "#5a6f891a",
         "hint.border": "#293b5bff",
-        "ignored": "#696B77ff",
-        "ignored.background": "#696B771a",
+        "ignored": "#878a98ff",
+        "ignored.background": "#696b771a",
         "ignored.border": "#464b57ff",
         "info": "#74ade8ff",
         "info.background": "#74ade81a",
@@ -131,7 +131,7 @@
         "success": "#a1c181ff",
         "success.background": "#a1c1811a",
         "success.border": "#38482fff",
-        "unreachable": "#838994ff",
+        "unreachable": "#a9afbcff",
         "unreachable.background": "#8389941a",
         "unreachable.border": "#464b57ff",
         "warning": "#dec184ff",
@@ -211,7 +211,7 @@
             "font_weight": null
           },
           "embedded": {
-            "color": "#c8ccd4ff",
+            "color": "#dce0e5ff",
             "font_style": null,
             "font_weight": null
           },
@@ -236,7 +236,7 @@
             "font_weight": null
           },
           "hint": {
-            "color": "#5a6f89ff",
+            "color": "#788ca6ff",
             "font_style": null,
             "font_weight": 700
           },
@@ -276,7 +276,7 @@
             "font_weight": null
           },
           "preproc": {
-            "color": "#c8ccd4ff",
+            "color": "#dce0e5ff",
             "font_style": null,
             "font_weight": null
           },
@@ -361,7 +361,7 @@
             "font_weight": null
           },
           "variable": {
-            "color": "#c8ccd4ff",
+            "color": "#dce0e5ff",
             "font_style": null,
             "font_weight": null
           },
@@ -402,15 +402,15 @@
         "ghost_element.active": "#cacacaff",
         "ghost_element.selected": "#cacacaff",
         "ghost_element.disabled": "#ebebecff",
-        "text": "#383a41ff",
-        "text.muted": "#7e8087ff",
-        "text.placeholder": "#a1a1a3ff",
-        "text.disabled": "#a1a1a3ff",
+        "text": "#242529ff",
+        "text.muted": "#58585aff",
+        "text.placeholder": "#7e8086ff",
+        "text.disabled": "#7e8086ff",
         "text.accent": "#5c78e2ff",
-        "icon": "#383a41ff",
-        "icon.muted": "#7e8087ff",
-        "icon.disabled": "#a1a1a3ff",
-        "icon.placeholder": "#7e8087ff",
+        "icon": "#242529ff",
+        "icon.muted": "#58585aff",
+        "icon.disabled": "#7e8086ff",
+        "icon.placeholder": "#58585aff",
         "icon.accent": "#5c78e2ff",
         "status_bar.background": "#dcdcddff",
         "title_bar.background": "#dcdcddff",
@@ -428,26 +428,26 @@
         "scrollbar.thumb.border": "#dfdfe0ff",
         "scrollbar.track.background": "#00000000",
         "scrollbar.track.border": "#eeeeeeff",
-        "editor.foreground": "#383a41ff",
+        "editor.foreground": "#242529ff",
         "editor.background": "#fafafaff",
         "editor.gutter.background": "#fafafaff",
         "editor.subheader.background": "#ebebecff",
         "editor.active_line.background": "#ebebecbf",
         "editor.highlighted_line.background": "#ebebecff",
         "editor.line_number": "#383a4159",
-        "editor.active_line_number": "#383a41ff",
+        "editor.active_line_number": "#242529ff",
         "editor.invisible": "#a3a3a4ff",
         "editor.wrap_guide": "#383a410d",
         "editor.active_wrap_guide": "#383a411a",
         "editor.document_highlight.read_background": "#5c78e21a",
         "editor.document_highlight.write_background": "#a3a3a466",
         "terminal.background": "#fafafaff",
-        "terminal.foreground": "#383a41ff",
-        "terminal.bright_foreground": "#383a41ff",
+        "terminal.foreground": "#242529ff",
+        "terminal.bright_foreground": "#242529ff",
         "terminal.dim_foreground": "#fafafaff",
         "terminal.ansi.black": "#fafafaff",
         "terminal.ansi.bright_black": "#aaaaaaff",
-        "terminal.ansi.dim_black": "#383a41ff",
+        "terminal.ansi.dim_black": "#242529ff",
         "terminal.ansi.red": "#d36151ff",
         "terminal.ansi.bright_red": "#f0b0a4ff",
         "terminal.ansi.dim_red": "#6f312aff",
@@ -466,11 +466,11 @@
         "terminal.ansi.cyan": "#3a82b7ff",
         "terminal.ansi.bright_cyan": "#a3bedaff",
         "terminal.ansi.dim_cyan": "#254058ff",
-        "terminal.ansi.white": "#383a41ff",
-        "terminal.ansi.bright_white": "#383a41ff",
+        "terminal.ansi.white": "#242529ff",
+        "terminal.ansi.bright_white": "#242529ff",
         "terminal.ansi.dim_white": "#97979aff",
         "link_text.hover": "#5c78e2ff",
-        "conflict": "#dec184ff",
+        "conflict": "#a48819ff",
         "conflict.background": "#faf2e6ff",
         "conflict.border": "#f4e7d1ff",
         "created": "#669f59ff",
@@ -482,19 +482,19 @@
         "error": "#d36151ff",
         "error.background": "#fbdfd9ff",
         "error.border": "#f6c6bdff",
-        "hidden": "#a1a1a3ff",
+        "hidden": "#7e8086ff",
         "hidden.background": "#dcdcddff",
         "hidden.border": "#d3d3d4ff",
-        "hint": "#9294beff",
+        "hint": "#7274a7ff",
         "hint.background": "#e2e2faff",
         "hint.border": "#cbcdf6ff",
-        "ignored": "#a1a1a3ff",
+        "ignored": "#7e8086ff",
         "ignored.background": "#dcdcddff",
         "ignored.border": "#c9c9caff",
         "info": "#5c78e2ff",
         "info.background": "#e2e2faff",
         "info.border": "#cbcdf6ff",
-        "modified": "#a47a23ff",
+        "modified": "#a48819ff",
         "modified.background": "#faf2e6ff",
         "modified.border": "#f4e7d1ff",
         "predictive": "#9b9ec6ff",
@@ -506,10 +506,10 @@
         "success": "#669f59ff",
         "success.background": "#dfeadbff",
         "success.border": "#c8dcc1ff",
-        "unreachable": "#7e8087ff",
+        "unreachable": "#58585aff",
         "unreachable.background": "#dcdcddff",
         "unreachable.border": "#c9c9caff",
-        "warning": "#dec184ff",
+        "warning": "#a48819ff",
         "warning.background": "#faf2e6ff",
         "warning.border": "#f4e7d1ff",
         "players": [
@@ -544,7 +544,7 @@
             "selection": "#d361513d"
           },
           {
-            "cursor": "#dec184ff",
+            "cursor": "#a48819ff",
             "background": "#dec184ff",
             "selection": "#dec1843d"
           },
@@ -586,7 +586,7 @@
             "font_weight": null
           },
           "embedded": {
-            "color": "#383a41ff",
+            "color": "#242529ff",
             "font_style": null,
             "font_weight": null
           },
@@ -611,7 +611,7 @@
             "font_weight": null
           },
           "hint": {
-            "color": "#9294beff",
+            "color": "#7274a7ff",
             "font_style": null,
             "font_weight": 700
           },
@@ -651,12 +651,12 @@
             "font_weight": null
           },
           "preproc": {
-            "color": "#383a41ff",
+            "color": "#242529ff",
             "font_style": null,
             "font_weight": null
           },
           "primary": {
-            "color": "#383a41ff",
+            "color": "#242529ff",
             "font_style": null,
             "font_weight": null
           },
@@ -666,7 +666,7 @@
             "font_weight": null
           },
           "punctuation": {
-            "color": "#383a41ff",
+            "color": "#242529ff",
             "font_style": null,
             "font_weight": null
           },
@@ -736,7 +736,7 @@
             "font_weight": null
           },
           "variable": {
-            "color": "#383a41ff",
+            "color": "#242529ff",
             "font_style": null,
             "font_weight": null
           },

assets/themes/solarized/solarized.json

@@ -519,8 +519,8 @@
             "selection": "#d337813d"
           },
           {
-            "cursor": "#cb4b17ff",
-            "background": "#cb4b17ff",
+            "cursor": "#cb4b16ff",
+            "background": "#cb4b16ff",
             "selection": "#cb4b173d"
           },
           {
@@ -596,7 +596,7 @@
             "font_weight": 700
           },
           "enum": {
-            "color": "#cb4b17ff",
+            "color": "#cb4b16ff",
             "font_style": null,
             "font_weight": null
           },
@@ -621,7 +621,7 @@
             "font_weight": null
           },
           "link_text": {
-            "color": "#cb4b17ff",
+            "color": "#cb4b16ff",
             "font_style": "italic",
             "font_weight": null
           },
@@ -636,7 +636,7 @@
             "font_weight": null
           },
           "operator": {
-            "color": "#cb4b17ff",
+            "color": "#cb4b16ff",
             "font_style": null,
             "font_weight": null
           },
@@ -686,7 +686,7 @@
             "font_weight": null
           },
           "string": {
-            "color": "#cb4b17ff",
+            "color": "#cb4b16ff",
             "font_style": null,
             "font_weight": null
           },
@@ -696,17 +696,17 @@
             "font_weight": null
           },
           "string.regex": {
-            "color": "#cb4b17ff",
+            "color": "#cb4b16ff",
             "font_style": null,
             "font_weight": null
           },
           "string.special": {
-            "color": "#cb4b17ff",
+            "color": "#cb4b16ff",
             "font_style": null,
             "font_weight": null
           },
           "string.special.symbol": {
-            "color": "#cb4b17ff",
+            "color": "#cb4b16ff",
             "font_style": null,
             "font_weight": null
           },
@@ -716,7 +716,7 @@
             "font_weight": null
           },
           "text.literal": {
-            "color": "#cb4b17ff",
+            "color": "#cb4b16ff",
             "font_style": null,
             "font_weight": null
           },

crates/activity_indicator/Cargo.toml

@@ -16,13 +16,14 @@ doctest = false
 anyhow.workspace = true
 auto_update.workspace = true
 editor.workspace = true
-extension.workspace = true
+extension_host.workspace = true
 futures.workspace = true
 gpui.workspace = true
 language.workspace = true
 project.workspace = true
 smallvec.workspace = true
 ui.workspace = true
+util.workspace = true
 workspace.workspace = true
 
 [dev-dependencies]

crates/activity_indicator/src/activity_indicator.rs

@@ -1,6 +1,6 @@
 use auto_update::{AutoUpdateStatus, AutoUpdater, DismissErrorMessage};
 use editor::Editor;
-use extension::ExtensionStore;
+use extension_host::ExtensionStore;
 use futures::StreamExt;
 use gpui::{
     actions, percentage, Animation, AnimationExt as _, AppContext, CursorStyle, EventEmitter,
@@ -13,7 +13,8 @@ use language::{
 use project::{EnvironmentErrorMessage, LanguageServerProgress, Project, WorktreeId};
 use smallvec::SmallVec;
 use std::{cmp::Reverse, fmt::Write, sync::Arc, time::Duration};
-use ui::{prelude::*, ButtonLike, ContextMenu, PopoverMenu, PopoverMenuHandle};
+use ui::{prelude::*, ButtonLike, ContextMenu, PopoverMenu, PopoverMenuHandle, Tooltip};
+use util::truncate_and_trailoff;
 use workspace::{item::ItemHandle, StatusItemView, Workspace};
 
 actions!(activity_indicator, [ShowErrorMessage]);
@@ -351,7 +352,10 @@ impl ActivityIndicator {
                         .into_any_element(),
                 ),
                 message: format!("Formatting failed: {}. Click to see logs.", failure),
-                on_click: Some(Arc::new(|_, cx| {
+                on_click: Some(Arc::new(|indicator, cx| {
+                    indicator.project.update(cx, |project, cx| {
+                        project.reset_last_formatting_failure(cx);
+                    });
                     cx.dispatch_action(Box::new(workspace::OpenLog));
                 })),
             });
@@ -446,6 +450,8 @@ impl ActivityIndicator {
 
 impl EventEmitter<Event> for ActivityIndicator {}
 
+const MAX_MESSAGE_LEN: usize = 50;
+
 impl Render for ActivityIndicator {
     fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
         let result = h_flex()
@@ -456,6 +462,7 @@ impl Render for ActivityIndicator {
             return result;
         };
         let this = cx.view().downgrade();
+        let truncate_content = content.message.len() > MAX_MESSAGE_LEN;
         result.gap_2().child(
             PopoverMenu::new("activity-indicator-popover")
                 .trigger(
@@ -464,7 +471,21 @@ impl Render for ActivityIndicator {
                             .id("activity-indicator-status")
                             .gap_2()
                             .children(content.icon)
-                            .child(Label::new(content.message).size(LabelSize::Small))
+                            .map(|button| {
+                                if truncate_content {
+                                    button
+                                        .child(
+                                            Label::new(truncate_and_trailoff(
+                                                &content.message,
+                                                MAX_MESSAGE_LEN,
+                                            ))
+                                            .size(LabelSize::Small),
+                                        )
+                                        .tooltip(move |cx| Tooltip::text(&content.message, cx))
+                                } else {
+                                    button.child(Label::new(content.message).size(LabelSize::Small))
+                                }
+                            })
                             .when_some(content.on_click, |this, handler| {
                                 this.on_click(cx.listener(move |this, _, cx| {
                                     handler(this, cx);

crates/assistant/src/assistant.rs

@@ -41,24 +41,26 @@ use prompts::PromptLoadingParams;
 use semantic_index::{CloudEmbeddingProvider, SemanticDb};
 use serde::{Deserialize, Serialize};
 use settings::{update_settings_file, Settings, SettingsStore};
-use slash_command::workflow_command::WorkflowSlashCommand;
+use slash_command::search_command::SearchSlashCommandFeatureFlag;
 use slash_command::{
     auto_command, cargo_workspace_command, context_server_command, default_command, delta_command,
     diagnostics_command, docs_command, fetch_command, file_command, now_command, project_command,
-    prompt_command, search_command, symbols_command, tab_command, terminal_command,
-    workflow_command,
+    prompt_command, search_command, selection_command, symbols_command, tab_command,
+    terminal_command,
 };
 use std::path::PathBuf;
 use std::sync::Arc;
 pub(crate) use streaming_diff::*;
 use util::ResultExt;
 
+use crate::slash_command::streaming_example_command;
 use crate::slash_command_settings::SlashCommandSettings;
 
 actions!(
     assistant,
     [
         Assist,
+        Edit,
         Split,
         CopyCode,
         CycleMessageRole,
@@ -211,21 +213,23 @@ pub fn init(
         });
     }
 
-    cx.spawn(|mut cx| {
-        let client = client.clone();
-        async move {
-            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),
-                &mut cx,
-            )
-            .await?;
+    if cx.has_flag::<SearchSlashCommandFeatureFlag>() {
+        cx.spawn(|mut cx| {
+            let client = client.clone();
+            async move {
+                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),
+                    &mut cx,
+                )
+                .await?;
 
-            cx.update(|cx| cx.set_global(semantic_index))
-        }
-    })
-    .detach();
+                cx.update(|cx| cx.set_global(semantic_index))
+            }
+        })
+        .detach();
+    }
 
     context_store::init(&client.clone().into());
     prompt_library::init(cx);
@@ -298,25 +302,64 @@ fn register_context_server_handlers(cx: &mut AppContext) {
                                     return;
                                 };
 
-                                if let Some(prompts) = protocol.list_prompts().await.log_err() {
-                                    for prompt in prompts
-                                        .into_iter()
-                                        .filter(context_server_command::acceptable_prompt)
-                                    {
-                                        log::info!(
-                                            "registering context server command: {:?}",
-                                            prompt.name
-                                        );
-                                        context_server_registry.register_command(
-                                            server.id.clone(),
-                                            prompt.name.as_str(),
-                                        );
-                                        slash_command_registry.register_command(
-                                            context_server_command::ContextServerSlashCommand::new(
-                                                &server, prompt,
-                                            ),
-                                            true,
-                                        );
+                                if protocol.capable(context_servers::protocol::ServerCapability::Prompts) {
+                                    if let Some(prompts) = protocol.list_prompts().await.log_err() {
+                                        for prompt in prompts
+                                            .into_iter()
+                                            .filter(context_server_command::acceptable_prompt)
+                                        {
+                                            log::info!(
+                                                "registering context server command: {:?}",
+                                                prompt.name
+                                            );
+                                            context_server_registry.register_command(
+                                                server.id.clone(),
+                                                prompt.name.as_str(),
+                                            );
+                                            slash_command_registry.register_command(
+                                                context_server_command::ContextServerSlashCommand::new(
+                                                    &server, prompt,
+                                                ),
+                                                true,
+                                            );
+                                        }
+                                    }
+                                }
+                            })
+                            .detach();
+                        }
+                    },
+                );
+
+                cx.update_model(
+                    &manager,
+                    |manager: &mut context_servers::manager::ContextServerManager, cx| {
+                        let tool_registry = ToolRegistry::global(cx);
+                        let context_server_registry = ContextServerRegistry::global(cx);
+                        if let Some(server) = manager.get_server(server_id) {
+                            cx.spawn(|_, _| async move {
+                                let Some(protocol) = server.client.read().clone() else {
+                                    return;
+                                };
+
+                                if protocol.capable(context_servers::protocol::ServerCapability::Tools) {
+                                    if let Some(tools) = protocol.list_tools().await.log_err() {
+                                        for tool in tools.tools {
+                                            log::info!(
+                                                "registering context server tool: {:?}",
+                                                tool.name
+                                            );
+                                            context_server_registry.register_tool(
+                                                server.id.clone(),
+                                                tool.name.as_str(),
+                                            );
+                                            tool_registry.register_tool(
+                                                tools::context_server_tool::ContextServerTool::new(
+                                                    server.id.clone(),
+                                                    tool
+                                                ),
+                                            );
+                                        }
                                     }
                                 }
                             })
@@ -334,6 +377,14 @@ fn register_context_server_handlers(cx: &mut AppContext) {
                         context_server_registry.unregister_command(&server_id, &command_name);
                     }
                 }
+
+                if let Some(tools) = context_server_registry.get_tools(server_id) {
+                    let tool_registry = ToolRegistry::global(cx);
+                    for tool_name in tools {
+                        tool_registry.unregister_tool_by_name(&tool_name);
+                        context_server_registry.unregister_tool(&server_id, &tool_name);
+                    }
+                }
             }
         },
     )
@@ -389,6 +440,7 @@ fn register_slash_commands(prompt_builder: Option<Arc<PromptBuilder>>, cx: &mut
     slash_command_registry
         .register_command(cargo_workspace_command::CargoWorkspaceSlashCommand, true);
     slash_command_registry.register_command(prompt_command::PromptSlashCommand, true);
+    slash_command_registry.register_command(selection_command::SelectionCommand, true);
     slash_command_registry.register_command(default_command::DefaultSlashCommand, false);
     slash_command_registry.register_command(terminal_command::TerminalSlashCommand, true);
     slash_command_registry.register_command(now_command::NowSlashCommand, false);
@@ -397,22 +449,6 @@ fn register_slash_commands(prompt_builder: Option<Arc<PromptBuilder>>, cx: &mut
     slash_command_registry.register_command(fetch_command::FetchSlashCommand, false);
 
     if let Some(prompt_builder) = prompt_builder {
-        cx.observe_global::<SettingsStore>({
-            let slash_command_registry = slash_command_registry.clone();
-            let prompt_builder = prompt_builder.clone();
-            move |cx| {
-                if AssistantSettings::get_global(cx).are_live_diffs_enabled(cx) {
-                    slash_command_registry.register_command(
-                        workflow_command::WorkflowSlashCommand::new(prompt_builder.clone()),
-                        true,
-                    );
-                } else {
-                    slash_command_registry.unregister_command_by_name(WorkflowSlashCommand::NAME);
-                }
-            }
-        })
-        .detach();
-
         cx.observe_flag::<project_command::ProjectSlashCommandFeatureFlag, _>({
             let slash_command_registry = slash_command_registry.clone();
             move |is_enabled, _cx| {
@@ -438,6 +474,19 @@ fn register_slash_commands(prompt_builder: Option<Arc<PromptBuilder>>, cx: &mut
     })
     .detach();
 
+    cx.observe_flag::<streaming_example_command::StreamingExampleSlashCommandFeatureFlag, _>({
+        let slash_command_registry = slash_command_registry.clone();
+        move |is_enabled, _cx| {
+            if is_enabled {
+                slash_command_registry.register_command(
+                    streaming_example_command::StreamingExampleSlashCommand,
+                    false,
+                );
+            }
+        }
+    })
+    .detach();
+
     update_slash_commands_from_settings(cx);
     cx.observe_global::<SettingsStore>(update_slash_commands_from_settings)
         .detach();

crates/assistant/src/assistant_settings.rs

@@ -410,7 +410,7 @@ pub struct AssistantSettingsContentV2 {
     ///
     /// Default: 320
     default_height: Option<f32>,
-    /// The default model to use when creating new contexts.
+    /// The default model to use when creating new chats.
     default_model: Option<LanguageModelSelection>,
     /// Additional models with which to generate alternatives when performing inline assists.
     inline_alternatives: Option<Vec<LanguageModelSelection>>,
@@ -498,11 +498,11 @@ pub struct LegacyAssistantSettingsContent {
     ///
     /// Default: 320
     pub default_height: Option<f32>,
-    /// The default OpenAI model to use when creating new contexts.
+    /// The default OpenAI model to use when creating new chats.
     ///
     /// Default: gpt-4-1106-preview
     pub default_open_ai_model: Option<OpenAiModel>,
-    /// OpenAI API base URL to use when creating new contexts.
+    /// OpenAI API base URL to use when creating new chats.
     ///
     /// Default: https://api.openai.com/v1
     pub openai_api_url: Option<String>,

crates/assistant/src/context/context_tests.rs

@@ -2,14 +2,19 @@ use super::{AssistantEdit, MessageCacheMetadata};
 use crate::{
     assistant_panel, prompt_library, slash_command::file_command, AssistantEditKind, CacheStatus,
     Context, ContextEvent, ContextId, ContextOperation, MessageId, MessageStatus, PromptBuilder,
+    SlashCommandId,
 };
 use anyhow::Result;
 use assistant_slash_command::{
-    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
-    SlashCommandRegistry, SlashCommandResult,
+    ArgumentCompletion, SlashCommand, SlashCommandContent, SlashCommandEvent, SlashCommandOutput,
+    SlashCommandOutputSection, SlashCommandRegistry, SlashCommandResult,
 };
-use collections::HashSet;
+use collections::{HashMap, HashSet};
 use fs::FakeFs;
+use futures::{
+    channel::mpsc,
+    stream::{self, StreamExt},
+};
 use gpui::{AppContext, Model, SharedString, Task, TestAppContext, WeakView};
 use language::{Buffer, BufferSnapshot, LanguageRegistry, LspAdapterDelegate};
 use language_model::{LanguageModelCacheConfiguration, LanguageModelRegistry, Role};
@@ -27,8 +32,8 @@ use std::{
     rc::Rc,
     sync::{atomic::AtomicBool, Arc},
 };
-use text::{network::Network, OffsetRangeExt as _, ReplicaId};
-use ui::{Context as _, WindowContext};
+use text::{network::Network, OffsetRangeExt as _, ReplicaId, ToOffset};
+use ui::{Context as _, IconName, WindowContext};
 use unindent::Unindent;
 use util::{
     test::{generate_marked_text, marked_text_ranges},
@@ -381,20 +386,41 @@ async fn test_slash_commands(cx: &mut TestAppContext) {
     let context =
         cx.new_model(|cx| Context::local(registry.clone(), None, None, prompt_builder.clone(), cx));
 
-    let output_ranges = Rc::new(RefCell::new(HashSet::default()));
+    #[derive(Default)]
+    struct ContextRanges {
+        parsed_commands: HashSet<Range<language::Anchor>>,
+        command_outputs: HashMap<SlashCommandId, Range<language::Anchor>>,
+        output_sections: HashSet<Range<language::Anchor>>,
+    }
+
+    let context_ranges = Rc::new(RefCell::new(ContextRanges::default()));
     context.update(cx, |_, cx| {
         cx.subscribe(&context, {
-            let ranges = output_ranges.clone();
-            move |_, _, event, _| match event {
-                ContextEvent::PendingSlashCommandsUpdated { removed, updated } => {
-                    for range in removed {
-                        ranges.borrow_mut().remove(range);
+            let context_ranges = context_ranges.clone();
+            move |context, _, event, _| {
+                let mut context_ranges = context_ranges.borrow_mut();
+                match event {
+                    ContextEvent::InvokedSlashCommandChanged { command_id } => {
+                        let command = context.invoked_slash_command(command_id).unwrap();
+                        context_ranges
+                            .command_outputs
+                            .insert(*command_id, command.range.clone());
                     }
-                    for command in updated {
-                        ranges.borrow_mut().insert(command.source_range.clone());
+                    ContextEvent::ParsedSlashCommandsUpdated { removed, updated } => {
+                        for range in removed {
+                            context_ranges.parsed_commands.remove(range);
+                        }
+                        for command in updated {
+                            context_ranges
+                                .parsed_commands
+                                .insert(command.source_range.clone());
+                        }
                     }
+                    ContextEvent::SlashCommandOutputSectionAdded { section } => {
+                        context_ranges.output_sections.insert(section.range.clone());
+                    }
+                    _ => {}
                 }
-                _ => {}
             }
         })
         .detach();
@@ -406,14 +432,12 @@ async fn test_slash_commands(cx: &mut TestAppContext) {
     buffer.update(cx, |buffer, cx| {
         buffer.edit([(0..0, "/file src/lib.rs")], None, cx);
     });
-    assert_text_and_output_ranges(
+    assert_text_and_context_ranges(
         &buffer,
-        &output_ranges.borrow(),
-        "
-        «/file src/lib.rs»
-        "
-        .unindent()
-        .trim_end(),
+        &context_ranges,
+        &"
+        «/file src/lib.rs»"
+            .unindent(),
         cx,
     );
 
@@ -422,14 +446,12 @@ async fn test_slash_commands(cx: &mut TestAppContext) {
         let edit_offset = buffer.text().find("lib.rs").unwrap();
         buffer.edit([(edit_offset..edit_offset + "lib".len(), "main")], None, cx);
     });
-    assert_text_and_output_ranges(
+    assert_text_and_context_ranges(
         &buffer,
-        &output_ranges.borrow(),
-        "
-        «/file src/main.rs»
-        "
-        .unindent()
-        .trim_end(),
+        &context_ranges,
+        &"
+        «/file src/main.rs»"
+            .unindent(),
         cx,
     );
 
@@ -442,36 +464,180 @@ async fn test_slash_commands(cx: &mut TestAppContext) {
             cx,
         );
     });
-    assert_text_and_output_ranges(
+    assert_text_and_context_ranges(
         &buffer,
-        &output_ranges.borrow(),
+        &context_ranges,
+        &"
+        /unknown src/main.rs"
+            .unindent(),
+        cx,
+    );
+
+    // Undoing the insertion of an non-existent slash command resorts the previous one.
+    buffer.update(cx, |buffer, cx| buffer.undo(cx));
+    assert_text_and_context_ranges(
+        &buffer,
+        &context_ranges,
+        &"
+        «/file src/main.rs»"
+            .unindent(),
+        cx,
+    );
+
+    let (command_output_tx, command_output_rx) = mpsc::unbounded();
+    context.update(cx, |context, cx| {
+        let command_source_range = context.parsed_slash_commands[0].source_range.clone();
+        context.insert_command_output(
+            command_source_range,
+            "file",
+            Task::ready(Ok(command_output_rx.boxed())),
+            true,
+            cx,
+        );
+    });
+    assert_text_and_context_ranges(
+        &buffer,
+        &context_ranges,
+        &"
+        ⟦«/file src/main.rs»
+        …⟧
         "
-        /unknown src/main.rs
+        .unindent(),
+        cx,
+    );
+
+    command_output_tx
+        .unbounded_send(Ok(SlashCommandEvent::StartSection {
+            icon: IconName::Ai,
+            label: "src/main.rs".into(),
+            metadata: None,
+        }))
+        .unwrap();
+    command_output_tx
+        .unbounded_send(Ok(SlashCommandEvent::Content("src/main.rs".into())))
+        .unwrap();
+    cx.run_until_parked();
+    assert_text_and_context_ranges(
+        &buffer,
+        &context_ranges,
+        &"
+        ⟦«/file src/main.rs»
+        src/main.rs…⟧
         "
-        .unindent()
-        .trim_end(),
+        .unindent(),
+        cx,
+    );
+
+    command_output_tx
+        .unbounded_send(Ok(SlashCommandEvent::Content("\nfn main() {}".into())))
+        .unwrap();
+    cx.run_until_parked();
+    assert_text_and_context_ranges(
+        &buffer,
+        &context_ranges,
+        &"
+        ⟦«/file src/main.rs»
+        src/main.rs
+        fn main() {}…⟧
+        "
+        .unindent(),
+        cx,
+    );
+
+    command_output_tx
+        .unbounded_send(Ok(SlashCommandEvent::EndSection { metadata: None }))
+        .unwrap();
+    cx.run_until_parked();
+    assert_text_and_context_ranges(
+        &buffer,
+        &context_ranges,
+        &"
+        ⟦«/file src/main.rs»
+        ⟪src/main.rs
+        fn main() {}⟫…⟧
+        "
+        .unindent(),
+        cx,
+    );
+
+    drop(command_output_tx);
+    cx.run_until_parked();
+    assert_text_and_context_ranges(
+        &buffer,
+        &context_ranges,
+        &"
+        ⟦⟪src/main.rs
+        fn main() {}⟫⟧
+        "
+        .unindent(),
         cx,
     );
 
     #[track_caller]
-    fn assert_text_and_output_ranges(
+    fn assert_text_and_context_ranges(
         buffer: &Model<Buffer>,
-        ranges: &HashSet<Range<language::Anchor>>,
+        ranges: &RefCell<ContextRanges>,
         expected_marked_text: &str,
         cx: &mut TestAppContext,
     ) {
-        let (expected_text, expected_ranges) = marked_text_ranges(expected_marked_text, false);
-        let (actual_text, actual_ranges) = buffer.update(cx, |buffer, _| {
-            let mut ranges = ranges
-                .iter()
-                .map(|range| range.to_offset(buffer))
-                .collect::<Vec<_>>();
-            ranges.sort_by_key(|a| a.start);
-            (buffer.text(), ranges)
+        let mut actual_marked_text = String::new();
+        buffer.update(cx, |buffer, _| {
+            struct Endpoint {
+                offset: usize,
+                marker: char,
+            }
+
+            let ranges = ranges.borrow();
+            let mut endpoints = Vec::new();
+            for range in ranges.command_outputs.values() {
+                endpoints.push(Endpoint {
+                    offset: range.start.to_offset(buffer),
+                    marker: '⟦',
+                });
+            }
+            for range in ranges.parsed_commands.iter() {
+                endpoints.push(Endpoint {
+                    offset: range.start.to_offset(buffer),
+                    marker: '«',
+                });
+            }
+            for range in ranges.output_sections.iter() {
+                endpoints.push(Endpoint {
+                    offset: range.start.to_offset(buffer),
+                    marker: '⟪',
+                });
+            }
+
+            for range in ranges.output_sections.iter() {
+                endpoints.push(Endpoint {
+                    offset: range.end.to_offset(buffer),
+                    marker: '⟫',
+                });
+            }
+            for range in ranges.parsed_commands.iter() {
+                endpoints.push(Endpoint {
+                    offset: range.end.to_offset(buffer),
+                    marker: '»',
+                });
+            }
+            for range in ranges.command_outputs.values() {
+                endpoints.push(Endpoint {
+                    offset: range.end.to_offset(buffer),
+                    marker: '⟧',
+                });
+            }
+
+            endpoints.sort_by_key(|endpoint| endpoint.offset);
+            let mut offset = 0;
+            for endpoint in endpoints {
+                actual_marked_text.extend(buffer.text_for_range(offset..endpoint.offset));
+                actual_marked_text.push(endpoint.marker);
+                offset = endpoint.offset;
+            }
+            actual_marked_text.extend(buffer.text_for_range(offset..buffer.len()));
         });
 
-        assert_eq!(actual_text, expected_text);
-        assert_eq!(actual_ranges, expected_ranges);
+        assert_eq!(actual_marked_text, expected_marked_text);
     }
 }
 
@@ -1063,44 +1229,57 @@ async fn test_random_context_collaboration(cx: &mut TestAppContext, mut rng: Std
                         offset + 1..offset + 1 + command_text.len()
                     });
 
-                    let output_len = rng.gen_range(1..=10);
                     let output_text = RandomCharIter::new(&mut rng)
                         .filter(|c| *c != '\r')
-                        .take(output_len)
+                        .take(10)
                         .collect::<String>();
 
+                    let mut events = vec![Ok(SlashCommandEvent::StartMessage {
+                        role: Role::User,
+                        merge_same_roles: true,
+                    })];
+
                     let num_sections = rng.gen_range(0..=3);
-                    let mut sections = Vec::with_capacity(num_sections);
+                    let mut section_start = 0;
                     for _ in 0..num_sections {
-                        let section_start = rng.gen_range(0..output_len);
-                        let section_end = rng.gen_range(section_start..=output_len);
-                        sections.push(SlashCommandOutputSection {
-                            range: section_start..section_end,
-                            icon: ui::IconName::Ai,
+                        let mut section_end = rng.gen_range(section_start..=output_text.len());
+                        while !output_text.is_char_boundary(section_end) {
+                            section_end += 1;
+                        }
+                        events.push(Ok(SlashCommandEvent::StartSection {
+                            icon: IconName::Ai,
                             label: "section".into(),
                             metadata: None,
-                        });
+                        }));
+                        events.push(Ok(SlashCommandEvent::Content(SlashCommandContent::Text {
+                            text: output_text[section_start..section_end].to_string(),
+                            run_commands_in_text: false,
+                        })));
+                        events.push(Ok(SlashCommandEvent::EndSection { metadata: None }));
+                        section_start = section_end;
+                    }
+
+                    if section_start < output_text.len() {
+                        events.push(Ok(SlashCommandEvent::Content(SlashCommandContent::Text {
+                            text: output_text[section_start..].to_string(),
+                            run_commands_in_text: false,
+                        })));
                     }
 
                     log::info!(
-                        "Context {}: insert slash command output at {:?} with {:?}",
+                        "Context {}: insert slash command output at {:?} with {:?} events",
                         context_index,
                         command_range,
-                        sections
+                        events.len()
                     );
 
                     let command_range = context.buffer.read(cx).anchor_after(command_range.start)
                         ..context.buffer.read(cx).anchor_after(command_range.end);
                     context.insert_command_output(
                         command_range,
-                        Task::ready(Ok(SlashCommandOutput {
-                            text: output_text,
-                            sections,
-                            run_commands_in_text: false,
-                        }
-                        .to_event_stream())),
+                        "/command",
+                        Task::ready(Ok(stream::iter(events).boxed())),
                         true,
-                        false,
                         cx,
                     );
                 });
@@ -1178,7 +1357,7 @@ async fn test_random_context_collaboration(cx: &mut TestAppContext, mut rng: Std
         let first_context = contexts[0].read(cx);
         for context in &contexts[1..] {
             let context = context.read(cx);
-            assert!(context.pending_ops.is_empty());
+            assert!(context.pending_ops.is_empty(), "pending ops: {:?}", context.pending_ops);
             assert_eq!(
                 context.buffer.read(cx).text(),
                 first_context.buffer.read(cx).text(),

crates/assistant/src/inline_assistant.rs

@@ -1,7 +1,7 @@
 use crate::{
     assistant_settings::AssistantSettings, humanize_token_count, prompts::PromptBuilder,
     AssistantPanel, AssistantPanelEvent, CharOperation, CycleNextInlineAssist,
-    CyclePreviousInlineAssist, LineDiff, LineOperation, ModelSelector, StreamingDiff,
+    CyclePreviousInlineAssist, LineDiff, LineOperation, ModelSelector, RequestType, StreamingDiff,
 };
 use anyhow::{anyhow, Context as _, Result};
 use client::{telemetry::Telemetry, ErrorExt};
@@ -21,9 +21,7 @@ use fs::Fs;
 use futures::{
     channel::mpsc,
     future::{BoxFuture, LocalBoxFuture},
-    join,
-    stream::{self, BoxStream},
-    SinkExt, Stream, StreamExt,
+    join, SinkExt, Stream, StreamExt,
 };
 use gpui::{
     anchored, deferred, point, AnyElement, AppContext, ClickEvent, EventEmitter, FocusHandle,
@@ -32,7 +30,8 @@ use gpui::{
 };
 use language::{Buffer, IndentKind, Point, Selection, TransactionId};
 use language_model::{
-    LanguageModel, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage, Role,
+    logging::report_assistant_event, LanguageModel, LanguageModelRegistry, LanguageModelRequest,
+    LanguageModelRequestMessage, LanguageModelTextStream, Role,
 };
 use multi_buffer::MultiBufferRow;
 use parking_lot::Mutex;
@@ -54,7 +53,9 @@ use telemetry_events::{AssistantEvent, AssistantKind, AssistantPhase};
 use terminal_view::terminal_panel::TerminalPanel;
 use text::{OffsetRangeExt, ToPoint as _};
 use theme::ThemeSettings;
-use ui::{prelude::*, text_for_action, CheckboxWithLabel, IconButtonShape, Popover, Tooltip};
+use ui::{
+    prelude::*, text_for_action, CheckboxWithLabel, IconButtonShape, KeyBinding, Popover, Tooltip,
+};
 use util::{RangeExt, ResultExt};
 use workspace::{notifications::NotificationId, ItemHandle, Toast, Workspace};
 
@@ -189,11 +190,16 @@ impl InlineAssistant {
         initial_prompt: Option<String>,
         cx: &mut WindowContext,
     ) {
-        let snapshot = editor.read(cx).buffer().read(cx).snapshot(cx);
+        let (snapshot, initial_selections) = editor.update(cx, |editor, cx| {
+            (
+                editor.buffer().read(cx).snapshot(cx),
+                editor.selections.all::<Point>(cx),
+            )
+        });
 
         let mut selections = Vec::<Selection<Point>>::new();
         let mut newest_selection = None;
-        for mut selection in editor.read(cx).selections.all::<Point>(cx) {
+        for mut selection in initial_selections {
             if selection.end > selection.start {
                 selection.start.column = 0;
                 // If the selection ends at the start of the line, we don't want to include it.
@@ -236,12 +242,13 @@ impl InlineAssistant {
             };
             codegen_ranges.push(start..end);
 
-            if let Some(telemetry) = self.telemetry.as_ref() {
-                if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
+            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
+                if let Some(telemetry) = self.telemetry.as_ref() {
                     telemetry.report_assistant_event(AssistantEvent {
                         conversation_id: None,
                         kind: AssistantKind::Inline,
                         phase: AssistantPhase::Invoked,
+                        message_id: None,
                         model: model.telemetry_id(),
                         model_provider: model.provider_id().to_string(),
                         response_latency: None,
@@ -566,10 +573,13 @@ impl InlineAssistant {
             return;
         };
 
-        let editor = editor.read(cx);
-        if editor.selections.count() == 1 {
-            let selection = editor.selections.newest::<usize>(cx);
-            let buffer = editor.buffer().read(cx).snapshot(cx);
+        if editor.read(cx).selections.count() == 1 {
+            let (selection, buffer) = editor.update(cx, |editor, cx| {
+                (
+                    editor.selections.newest::<usize>(cx),
+                    editor.buffer().read(cx).snapshot(cx),
+                )
+            });
             for assist_id in &editor_assists.assist_ids {
                 let assist = &self.assists[assist_id];
                 let assist_range = assist.range.to_offset(&buffer);
@@ -594,10 +604,13 @@ impl InlineAssistant {
             return;
         };
 
-        let editor = editor.read(cx);
-        if editor.selections.count() == 1 {
-            let selection = editor.selections.newest::<usize>(cx);
-            let buffer = editor.buffer().read(cx).snapshot(cx);
+        if editor.read(cx).selections.count() == 1 {
+            let (selection, buffer) = editor.update(cx, |editor, cx| {
+                (
+                    editor.selections.newest::<usize>(cx),
+                    editor.buffer().read(cx).snapshot(cx),
+                )
+            });
             let mut closest_assist_fallback = None;
             for assist_id in &editor_assists.assist_ids {
                 let assist = &self.assists[assist_id];
@@ -743,33 +756,6 @@ impl InlineAssistant {
 
     pub fn finish_assist(&mut self, assist_id: InlineAssistId, undo: bool, cx: &mut WindowContext) {
         if let Some(assist) = self.assists.get(&assist_id) {
-            if let Some(telemetry) = self.telemetry.as_ref() {
-                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 ranges = multibuffer.range_to_buffer_ranges(assist.range.clone(), cx);
-                        ranges
-                            .first()
-                            .and_then(|(buffer, _, _)| buffer.read(cx).language())
-                            .map(|language| language.name())
-                    });
-                    telemetry.report_assistant_event(AssistantEvent {
-                        conversation_id: None,
-                        kind: AssistantKind::Inline,
-                        phase: if undo {
-                            AssistantPhase::Rejected
-                        } else {
-                            AssistantPhase::Accepted
-                        },
-                        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()),
-                    });
-                }
-            }
-
             let assist_group_id = assist.group_id;
             if self.assist_groups[&assist_group_id].linked {
                 for assist_id in self.unlink_assist_group(assist_group_id, cx) {
@@ -804,12 +790,45 @@ impl InlineAssistant {
                 }
             }
 
+            let active_alternative = assist.codegen.read(cx).active_alternative().clone();
+            let message_id = active_alternative.read(cx).message_id.clone();
+
+            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
+                let language_name = assist.editor.upgrade().and_then(|editor| {
+                    let multibuffer = editor.read(cx).buffer().read(cx);
+                    let ranges = multibuffer.range_to_buffer_ranges(assist.range.clone(), cx);
+                    ranges
+                        .first()
+                        .and_then(|(buffer, _, _)| buffer.read(cx).language())
+                        .map(|language| language.name())
+                });
+                report_assistant_event(
+                    AssistantEvent {
+                        conversation_id: None,
+                        kind: AssistantKind::Inline,
+                        message_id,
+                        phase: if undo {
+                            AssistantPhase::Rejected
+                        } else {
+                            AssistantPhase::Accepted
+                        },
+                        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()),
+                    },
+                    self.telemetry.clone(),
+                    cx.http_client(),
+                    model.api_key(cx),
+                    cx.background_executor(),
+                );
+            }
+
             if undo {
                 assist.codegen.update(cx, |codegen, cx| codegen.undo(cx));
             } else {
-                let confirmed_alternative = assist.codegen.read(cx).active_alternative().clone();
-                self.confirmed_assists
-                    .insert(assist_id, confirmed_alternative);
+                self.confirmed_assists.insert(assist_id, active_alternative);
             }
         }
     }
@@ -1882,21 +1901,58 @@ impl PromptEditor {
         let codegen = self.codegen.read(cx);
         let disabled = matches!(codegen.status(cx), CodegenStatus::Idle);
 
+        let model_registry = LanguageModelRegistry::read_global(cx);
+        let default_model = model_registry.active_model();
+        let alternative_models = model_registry.inline_alternative_models();
+
+        let get_model_name = |index: usize| -> String {
+            let name = |model: &Arc<dyn LanguageModel>| model.name().0.to_string();
+
+            match index {
+                0 => default_model.as_ref().map_or_else(String::new, name),
+                index if index <= alternative_models.len() => alternative_models
+                    .get(index - 1)
+                    .map_or_else(String::new, name),
+                _ => String::new(),
+            }
+        };
+
+        let total_models = alternative_models.len() + 1;
+
+        if total_models <= 1 {
+            return div().into_any_element();
+        }
+
+        let current_index = codegen.active_alternative;
+        let prev_index = (current_index + total_models - 1) % total_models;
+        let next_index = (current_index + 1) % total_models;
+
+        let prev_model_name = get_model_name(prev_index);
+        let next_model_name = get_model_name(next_index);
+
         h_flex()
             .child(
                 IconButton::new("previous", IconName::ChevronLeft)
                     .icon_color(Color::Muted)
-                    .disabled(disabled)
+                    .disabled(disabled || current_index == 0)
                     .shape(IconButtonShape::Square)
                     .tooltip({
                         let focus_handle = self.editor.focus_handle(cx);
                         move |cx| {
-                            Tooltip::for_action_in(
-                                "Previous Alternative",
-                                &CyclePreviousInlineAssist,
-                                &focus_handle,
-                                cx,
-                            )
+                            cx.new_view(|cx| {
+                                let mut tooltip = Tooltip::new("Previous Alternative").key_binding(
+                                    KeyBinding::for_action_in(
+                                        &CyclePreviousInlineAssist,
+                                        &focus_handle,
+                                        cx,
+                                    ),
+                                );
+                                if !disabled && current_index != 0 {
+                                    tooltip = tooltip.meta(prev_model_name.clone());
+                                }
+                                tooltip
+                            })
+                            .into()
                         }
                     })
                     .on_click(cx.listener(|this, _, cx| {
@@ -1920,17 +1976,25 @@ impl PromptEditor {
             .child(
                 IconButton::new("next", IconName::ChevronRight)
                     .icon_color(Color::Muted)
-                    .disabled(disabled)
+                    .disabled(disabled || current_index == total_models - 1)
                     .shape(IconButtonShape::Square)
                     .tooltip({
                         let focus_handle = self.editor.focus_handle(cx);
                         move |cx| {
-                            Tooltip::for_action_in(
-                                "Next Alternative",
-                                &CycleNextInlineAssist,
-                                &focus_handle,
-                                cx,
-                            )
+                            cx.new_view(|cx| {
+                                let mut tooltip = Tooltip::new("Next Alternative").key_binding(
+                                    KeyBinding::for_action_in(
+                                        &CycleNextInlineAssist,
+                                        &focus_handle,
+                                        cx,
+                                    ),
+                                );
+                                if !disabled && current_index != total_models - 1 {
+                                    tooltip = tooltip.meta(next_model_name.clone());
+                                }
+                                tooltip
+                            })
+                            .into()
                         }
                     })
                     .on_click(cx.listener(|this, _, cx| {
@@ -2234,7 +2298,7 @@ impl InlineAssist {
                     .read(cx)
                     .active_context(cx)?
                     .read(cx)
-                    .to_completion_request(cx),
+                    .to_completion_request(RequestType::Chat, cx),
             )
         } else {
             None
@@ -2486,6 +2550,7 @@ pub struct CodegenAlternative {
     line_operations: Vec<LineOperation>,
     request: Option<LanguageModelRequest>,
     elapsed_time: Option<f64>,
+    message_id: Option<String>,
 }
 
 enum CodegenStatus {
@@ -2544,6 +2609,7 @@ impl CodegenAlternative {
             buffer: buffer.clone(),
             old_buffer,
             edit_position: None,
+            message_id: None,
             snapshot,
             last_equal_ranges: Default::default(),
             transformation_transaction_id: None,
@@ -2648,20 +2714,20 @@ impl CodegenAlternative {
 
         self.edit_position = Some(self.range.start.bias_right(&self.snapshot));
 
+        let api_key = model.api_key(cx);
         let telemetry_id = model.telemetry_id();
         let provider_id = model.provider_id();
-        let chunks: LocalBoxFuture<Result<BoxStream<Result<String>>>> =
+        let stream: LocalBoxFuture<Result<LanguageModelTextStream>> =
             if user_prompt.trim().to_lowercase() == "delete" {
-                async { Ok(stream::empty().boxed()) }.boxed_local()
+                async { Ok(LanguageModelTextStream::default()) }.boxed_local()
             } else {
                 let request = self.build_request(user_prompt, assistant_panel_context, cx)?;
                 self.request = Some(request.clone());
 
-                let chunks = cx
-                    .spawn(|_, cx| async move { model.stream_completion_text(request, &cx).await });
-                async move { Ok(chunks.await?.boxed()) }.boxed_local()
+                cx.spawn(|_, cx| async move { model.stream_completion_text(request, &cx).await })
+                    .boxed_local()
             };
-        self.handle_stream(telemetry_id, provider_id.to_string(), chunks, cx);
+        self.handle_stream(telemetry_id, provider_id.to_string(), api_key, stream, cx);
         Ok(())
     }
 
@@ -2726,7 +2792,8 @@ impl CodegenAlternative {
         &mut self,
         model_telemetry_id: String,
         model_provider_id: String,
-        stream: impl 'static + Future<Output = Result<BoxStream<'static, Result<String>>>>,
+        model_api_key: Option<String>,
+        stream: impl 'static + Future<Output = Result<LanguageModelTextStream>>,
         cx: &mut ModelContext<Self>,
     ) {
         let start_time = Instant::now();
@@ -2756,6 +2823,7 @@ impl CodegenAlternative {
             }
         }
 
+        let http_client = cx.http_client().clone();
         let telemetry = self.telemetry.clone();
         let language_name = {
             let multibuffer = self.buffer.read(cx);
@@ -2771,15 +2839,21 @@ impl CodegenAlternative {
         let mut edit_start = self.range.start.to_offset(&snapshot);
         self.generation = cx.spawn(|codegen, mut cx| {
             async move {
-                let chunks = stream.await;
+                let stream = stream.await;
+                let message_id = stream
+                    .as_ref()
+                    .ok()
+                    .and_then(|stream| stream.message_id.clone());
                 let generate = async {
                     let (mut diff_tx, mut diff_rx) = mpsc::channel(1);
+                    let executor = cx.background_executor().clone();
+                    let message_id = message_id.clone();
                     let line_based_stream_diff: Task<anyhow::Result<()>> =
                         cx.background_executor().spawn(async move {
                             let mut response_latency = None;
                             let request_start = Instant::now();
                             let diff = async {
-                                let chunks = StripInvalidSpans::new(chunks?);
+                                let chunks = StripInvalidSpans::new(stream?.stream);
                                 futures::pin_mut!(chunks);
                                 let mut diff = StreamingDiff::new(selected_text.to_string());
                                 let mut line_diff = LineDiff::default();
@@ -2875,9 +2949,10 @@ impl CodegenAlternative {
 
                             let error_message =
                                 result.as_ref().err().map(|error| error.to_string());
-                            if let Some(telemetry) = telemetry {
-                                telemetry.report_assistant_event(AssistantEvent {
+                            report_assistant_event(
+                                AssistantEvent {
                                     conversation_id: None,
+                                    message_id,
                                     kind: AssistantKind::Inline,
                                     phase: AssistantPhase::Response,
                                     model: model_telemetry_id,
@@ -2885,8 +2960,12 @@ impl CodegenAlternative {
                                     response_latency,
                                     error_message,
                                     language_name: language_name.map(|name| name.to_proto()),
-                                });
-                            }
+                                },
+                                telemetry,
+                                http_client,
+                                model_api_key,
+                                &executor,
+                            );
 
                             result?;
                             Ok(())
@@ -2950,6 +3029,7 @@ impl CodegenAlternative {
 
                 codegen
                     .update(&mut cx, |this, cx| {
+                        this.message_id = message_id;
                         this.last_equal_ranges.clear();
                         if let Err(error) = result {
                             this.status = CodegenStatus::Error(error);
@@ -3501,15 +3581,7 @@ mod tests {
             )
         });
 
-        let (chunks_tx, chunks_rx) = mpsc::unbounded();
-        codegen.update(cx, |codegen, cx| {
-            codegen.handle_stream(
-                String::new(),
-                String::new(),
-                future::ready(Ok(chunks_rx.map(Ok).boxed())),
-                cx,
-            )
-        });
+        let chunks_tx = simulate_response_stream(codegen.clone(), cx);
 
         let mut new_text = concat!(
             "       let mut x = 0;\n",
@@ -3573,15 +3645,7 @@ mod tests {
             )
         });
 
-        let (chunks_tx, chunks_rx) = mpsc::unbounded();
-        codegen.update(cx, |codegen, cx| {
-            codegen.handle_stream(
-                String::new(),
-                String::new(),
-                future::ready(Ok(chunks_rx.map(Ok).boxed())),
-                cx,
-            )
-        });
+        let chunks_tx = simulate_response_stream(codegen.clone(), cx);
 
         cx.background_executor.run_until_parked();
 
@@ -3648,15 +3712,7 @@ mod tests {
             )
         });
 
-        let (chunks_tx, chunks_rx) = mpsc::unbounded();
-        codegen.update(cx, |codegen, cx| {
-            codegen.handle_stream(
-                String::new(),
-                String::new(),
-                future::ready(Ok(chunks_rx.map(Ok).boxed())),
-                cx,
-            )
-        });
+        let chunks_tx = simulate_response_stream(codegen.clone(), cx);
 
         cx.background_executor.run_until_parked();
 
@@ -3722,16 +3778,7 @@ mod tests {
             )
         });
 
-        let (chunks_tx, chunks_rx) = mpsc::unbounded();
-        codegen.update(cx, |codegen, cx| {
-            codegen.handle_stream(
-                String::new(),
-                String::new(),
-                future::ready(Ok(chunks_rx.map(Ok).boxed())),
-                cx,
-            )
-        });
-
+        let chunks_tx = simulate_response_stream(codegen.clone(), cx);
         let new_text = concat!(
             "func main() {\n",
             "\tx := 0\n",
@@ -3786,16 +3833,7 @@ mod tests {
             )
         });
 
-        let (chunks_tx, chunks_rx) = mpsc::unbounded();
-        codegen.update(cx, |codegen, cx| {
-            codegen.handle_stream(
-                String::new(),
-                String::new(),
-                future::ready(Ok(chunks_rx.map(Ok).boxed())),
-                cx,
-            )
-        });
-
+        let chunks_tx = simulate_response_stream(codegen.clone(), cx);
         chunks_tx
             .unbounded_send("let mut x = 0;\nx += 1;".to_string())
             .unwrap();
@@ -3869,6 +3907,26 @@ mod tests {
         }
     }
 
+    fn simulate_response_stream(
+        codegen: Model<CodegenAlternative>,
+        cx: &mut TestAppContext,
+    ) -> mpsc::UnboundedSender<String> {
+        let (chunks_tx, chunks_rx) = mpsc::unbounded();
+        codegen.update(cx, |codegen, cx| {
+            codegen.handle_stream(
+                String::new(),
+                String::new(),
+                None,
+                future::ready(Ok(LanguageModelTextStream {
+                    message_id: None,
+                    stream: chunks_rx.map(Ok).boxed(),
+                })),
+                cx,
+            );
+        });
+        chunks_tx
+    }
+
     fn rust_lang() -> Language {
         Language::new(
             LanguageConfig {

crates/assistant/src/prompts.rs

@@ -310,8 +310,8 @@ impl PromptBuilder {
             .render("terminal_assistant_prompt", &context)
     }
 
-    pub fn generate_workflow_prompt(&self) -> Result<String, RenderError> {
-        self.handlebars.lock().render("edit_workflow", &())
+    pub fn generate_suggest_edits_prompt(&self) -> Result<String, RenderError> {
+        self.handlebars.lock().render("suggest_edits", &())
     }
 
     pub fn generate_project_slash_command_prompt(

crates/assistant/src/slash_command.rs

@@ -31,10 +31,11 @@ pub mod now_command;
 pub mod project_command;
 pub mod prompt_command;
 pub mod search_command;
+pub mod selection_command;
+pub mod streaming_example_command;
 pub mod symbols_command;
 pub mod tab_command;
 pub mod terminal_command;
-pub mod workflow_command;
 
 pub(crate) struct SlashCommandCompletionProvider {
     cancel_flag: Mutex<Arc<AtomicBool>>,
@@ -126,7 +127,6 @@ impl SlashCommandCompletionProvider {
                                                             &command_name,
                                                             &[],
                                                             true,
-                                                            false,
                                                             workspace.clone(),
                                                             cx,
                                                         );
@@ -211,7 +211,6 @@ impl SlashCommandCompletionProvider {
                                                             &command_name,
                                                             &completed_arguments,
                                                             true,
-                                                            false,
                                                             workspace.clone(),
                                                             cx,
                                                         );

crates/assistant/src/slash_command/auto_command.rs

@@ -14,7 +14,7 @@ use language_model::{
 use semantic_index::{FileSummary, SemanticDb};
 use smol::channel;
 use std::sync::{atomic::AtomicBool, Arc};
-use ui::{BorrowAppContext, WindowContext};
+use ui::{prelude::*, BorrowAppContext, WindowContext};
 use util::ResultExt;
 use workspace::Workspace;
 
@@ -37,6 +37,10 @@ impl SlashCommand for AutoCommand {
         "Automatically infer what context to add".into()
     }
 
+    fn icon(&self) -> IconName {
+        IconName::Wand
+    }
+
     fn menu_text(&self) -> String {
         self.description()
     }

crates/assistant/src/slash_command/delta_command.rs

@@ -10,6 +10,7 @@ use gpui::{Task, WeakView, WindowContext};
 use language::{BufferSnapshot, LspAdapterDelegate};
 use std::sync::{atomic::AtomicBool, Arc};
 use text::OffsetRangeExt;
+use ui::prelude::*;
 use workspace::Workspace;
 
 pub(crate) struct DeltaSlashCommand;
@@ -27,6 +28,10 @@ impl SlashCommand for DeltaSlashCommand {
         self.description()
     }
 
+    fn icon(&self) -> IconName {
+        IconName::Diff
+    }
+
     fn requires_argument(&self) -> bool {
         false
     }
@@ -53,6 +58,7 @@ impl SlashCommand for DeltaSlashCommand {
         let mut paths = HashSet::default();
         let mut file_command_old_outputs = Vec::new();
         let mut file_command_new_outputs = Vec::new();
+
         for section in context_slash_command_output_sections.iter().rev() {
             if let Some(metadata) = section
                 .metadata
@@ -79,6 +85,7 @@ impl SlashCommand for DeltaSlashCommand {
 
         cx.background_executor().spawn(async move {
             let mut output = SlashCommandOutput::default();
+            let mut changes_detected = false;
 
             let file_command_new_outputs = future::join_all(file_command_new_outputs).await;
             for (old_text, new_output) in file_command_old_outputs
@@ -91,6 +98,7 @@ impl SlashCommand for DeltaSlashCommand {
                         if let Some(file_command_range) = new_output.sections.first() {
                             let new_text = &new_output.text[file_command_range.range.clone()];
                             if old_text.chars().ne(new_text.chars()) {
+                                changes_detected = true;
                                 output.sections.extend(new_output.sections.into_iter().map(
                                     |section| SlashCommandOutputSection {
                                         range: output.text.len() + section.range.start
@@ -107,6 +115,10 @@ impl SlashCommand for DeltaSlashCommand {
                 }
             }
 
+            if !changes_detected {
+                return Err(anyhow!("no new changes detected"));
+            }
+
             Ok(output.to_event_stream())
         })
     }

crates/assistant/src/slash_command/diagnostics_command.rs

@@ -98,6 +98,10 @@ impl SlashCommand for DiagnosticsSlashCommand {
         "Insert diagnostics".into()
     }
 
+    fn icon(&self) -> IconName {
+        IconName::XCircle
+    }
+
     fn menu_text(&self) -> String {
         self.description()
     }

crates/assistant/src/slash_command/file_command.rs

@@ -21,8 +21,6 @@ use ui::prelude::*;
 use util::ResultExt;
 use workspace::Workspace;
 
-use crate::slash_command::diagnostics_command::collect_buffer_diagnostics;
-
 pub(crate) struct FileSlashCommand;
 
 impl FileSlashCommand {
@@ -117,7 +115,7 @@ impl SlashCommand for FileSlashCommand {
     }
 
     fn description(&self) -> String {
-        "Insert file".into()
+        "Insert file and/or directory".into()
     }
 
     fn menu_text(&self) -> String {
@@ -128,6 +126,10 @@ impl SlashCommand for FileSlashCommand {
         true
     }
 
+    fn icon(&self) -> IconName {
+        IconName::File
+    }
+
     fn complete_argument(
         self: Arc<Self>,
         arguments: &[String],
@@ -539,8 +541,6 @@ pub fn append_buffer_to_output(
     output.text.push('\n');
 
     let section_ix = output.sections.len();
-    collect_buffer_diagnostics(output, buffer, false);
-
     output.sections.insert(
         section_ix,
         build_entry_output_section(prev_len..output.text.len(), path, false, None),

crates/assistant/src/slash_command/project_command.rs

@@ -24,7 +24,8 @@ use std::{
     ops::DerefMut,
     sync::{atomic::AtomicBool, Arc},
 };
-use ui::{BorrowAppContext as _, IconName};
+
+use ui::prelude::*;
 use workspace::Workspace;
 
 pub struct ProjectSlashCommand {
@@ -50,6 +51,10 @@ impl SlashCommand for ProjectSlashCommand {
         "Generate a semantic search based on context".into()
     }
 
+    fn icon(&self) -> IconName {
+        IconName::Folder
+    }
+
     fn menu_text(&self) -> String {
         self.description()
     }

crates/assistant/src/slash_command/prompt_command.rs

@@ -21,6 +21,10 @@ impl SlashCommand for PromptSlashCommand {
         "Insert prompt from library".into()
     }
 
+    fn icon(&self) -> IconName {
+        IconName::Library
+    }
+
     fn menu_text(&self) -> String {
         self.description()
     }

crates/assistant/src/slash_command/search_command.rs

@@ -21,6 +21,10 @@ pub(crate) struct SearchSlashCommandFeatureFlag;
 
 impl FeatureFlag for SearchSlashCommandFeatureFlag {
     const NAME: &'static str = "search-slash-command";
+
+    fn enabled_for_staff() -> bool {
+        false
+    }
 }
 
 pub(crate) struct SearchSlashCommand;
@@ -38,6 +42,10 @@ impl SlashCommand for SearchSlashCommand {
         "Search your project semantically".into()
     }
 
+    fn icon(&self) -> IconName {
+        IconName::SearchCode
+    }
+
     fn menu_text(&self) -> String {
         self.description()
     }

crates/assistant/src/slash_command/selection_command.rs

@@ -0,0 +1,98 @@
+use crate::assistant_panel::selections_creases;
+use anyhow::{anyhow, Result};
+use assistant_slash_command::{
+    ArgumentCompletion, SlashCommand, SlashCommandContent, SlashCommandEvent,
+    SlashCommandOutputSection, SlashCommandResult,
+};
+use futures::StreamExt;
+use gpui::{AppContext, Task, WeakView};
+use language::{BufferSnapshot, CodeLabel, LspAdapterDelegate};
+use std::sync::atomic::AtomicBool;
+use std::sync::Arc;
+use ui::{IconName, SharedString, WindowContext};
+use workspace::Workspace;
+
+pub(crate) struct SelectionCommand;
+
+impl SlashCommand for SelectionCommand {
+    fn name(&self) -> String {
+        "selection".into()
+    }
+
+    fn label(&self, _cx: &AppContext) -> CodeLabel {
+        CodeLabel::plain(self.name(), None)
+    }
+
+    fn description(&self) -> String {
+        "Insert editor selection".into()
+    }
+
+    fn icon(&self) -> IconName {
+        IconName::Quote
+    }
+
+    fn menu_text(&self) -> String {
+        self.description()
+    }
+
+    fn requires_argument(&self) -> bool {
+        false
+    }
+
+    fn accepts_arguments(&self) -> bool {
+        true
+    }
+
+    fn complete_argument(
+        self: Arc<Self>,
+        _arguments: &[String],
+        _cancel: Arc<AtomicBool>,
+        _workspace: Option<WeakView<Workspace>>,
+        _cx: &mut WindowContext,
+    ) -> Task<Result<Vec<ArgumentCompletion>>> {
+        Task::ready(Err(anyhow!("this command does not require argument")))
+    }
+
+    fn run(
+        self: Arc<Self>,
+        _arguments: &[String],
+        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
+        _context_buffer: BufferSnapshot,
+        workspace: WeakView<Workspace>,
+        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
+        cx: &mut WindowContext,
+    ) -> Task<SlashCommandResult> {
+        let mut events = vec![];
+
+        let Some(creases) = workspace
+            .update(cx, selections_creases)
+            .unwrap_or_else(|e| {
+                events.push(Err(e));
+                None
+            })
+        else {
+            return Task::ready(Err(anyhow!("no active selection")));
+        };
+
+        for (text, title) in creases {
+            events.push(Ok(SlashCommandEvent::StartSection {
+                icon: IconName::TextSnippet,
+                label: SharedString::from(title),
+                metadata: None,
+            }));
+            events.push(Ok(SlashCommandEvent::Content(SlashCommandContent::Text {
+                text,
+                run_commands_in_text: false,
+            })));
+            events.push(Ok(SlashCommandEvent::EndSection { metadata: None }));
+            events.push(Ok(SlashCommandEvent::Content(SlashCommandContent::Text {
+                text: "\n".to_string(),
+                run_commands_in_text: false,
+            })));
+        }
+
+        let result = futures::stream::iter(events).boxed();
+
+        Task::ready(Ok(result))
+    }
+}

crates/assistant/src/slash_command/streaming_example_command.rs

@@ -0,0 +1,118 @@
+use std::sync::atomic::AtomicBool;
+use std::sync::Arc;
+use std::time::Duration;
+
+use anyhow::Result;
+use assistant_slash_command::{
+    ArgumentCompletion, SlashCommand, SlashCommandContent, SlashCommandEvent,
+    SlashCommandOutputSection, SlashCommandResult,
+};
+use feature_flags::FeatureFlag;
+use futures::channel::mpsc;
+use gpui::{Task, WeakView};
+use language::{BufferSnapshot, LspAdapterDelegate};
+use smol::stream::StreamExt;
+use smol::Timer;
+use ui::prelude::*;
+use workspace::Workspace;
+
+pub struct StreamingExampleSlashCommandFeatureFlag;
+
+impl FeatureFlag for StreamingExampleSlashCommandFeatureFlag {
+    const NAME: &'static str = "streaming-example-slash-command";
+}
+
+pub(crate) struct StreamingExampleSlashCommand;
+
+impl SlashCommand for StreamingExampleSlashCommand {
+    fn name(&self) -> String {
+        "streaming-example".into()
+    }
+
+    fn description(&self) -> String {
+        "An example slash command that showcases streaming.".into()
+    }
+
+    fn menu_text(&self) -> String {
+        self.description()
+    }
+
+    fn requires_argument(&self) -> bool {
+        false
+    }
+
+    fn complete_argument(
+        self: Arc<Self>,
+        _arguments: &[String],
+        _cancel: Arc<AtomicBool>,
+        _workspace: Option<WeakView<Workspace>>,
+        _cx: &mut WindowContext,
+    ) -> Task<Result<Vec<ArgumentCompletion>>> {
+        Task::ready(Ok(Vec::new()))
+    }
+
+    fn run(
+        self: Arc<Self>,
+        _arguments: &[String],
+        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
+        _context_buffer: BufferSnapshot,
+        _workspace: WeakView<Workspace>,
+        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
+        cx: &mut WindowContext,
+    ) -> Task<SlashCommandResult> {
+        let (events_tx, events_rx) = mpsc::unbounded();
+        cx.background_executor()
+            .spawn(async move {
+                events_tx.unbounded_send(Ok(SlashCommandEvent::StartSection {
+                    icon: IconName::FileRust,
+                    label: "Section 1".into(),
+                    metadata: None,
+                }))?;
+                events_tx.unbounded_send(Ok(SlashCommandEvent::Content(
+                    SlashCommandContent::Text {
+                        text: "Hello".into(),
+                        run_commands_in_text: false,
+                    },
+                )))?;
+                events_tx.unbounded_send(Ok(SlashCommandEvent::EndSection { metadata: None }))?;
+
+                Timer::after(Duration::from_secs(1)).await;
+
+                events_tx.unbounded_send(Ok(SlashCommandEvent::StartSection {
+                    icon: IconName::FileRust,
+                    label: "Section 2".into(),
+                    metadata: None,
+                }))?;
+                events_tx.unbounded_send(Ok(SlashCommandEvent::Content(
+                    SlashCommandContent::Text {
+                        text: "World".into(),
+                        run_commands_in_text: false,
+                    },
+                )))?;
+                events_tx.unbounded_send(Ok(SlashCommandEvent::EndSection { metadata: None }))?;
+
+                for n in 1..=10 {
+                    Timer::after(Duration::from_secs(1)).await;
+
+                    events_tx.unbounded_send(Ok(SlashCommandEvent::StartSection {
+                        icon: IconName::StarFilled,
+                        label: format!("Section {n}").into(),
+                        metadata: None,
+                    }))?;
+                    events_tx.unbounded_send(Ok(SlashCommandEvent::Content(
+                        SlashCommandContent::Text {
+                            text: "lorem ipsum ".repeat(n).trim().into(),
+                            run_commands_in_text: false,
+                        },
+                    )))?;
+                    events_tx
+                        .unbounded_send(Ok(SlashCommandEvent::EndSection { metadata: None }))?;
+                }
+
+                anyhow::Ok(())
+            })
+            .detach_and_log_err(cx);
+
+        Task::ready(Ok(events_rx.boxed()))
+    }
+}

crates/assistant/src/slash_command/symbols_command.rs

@@ -22,6 +22,10 @@ impl SlashCommand for OutlineSlashCommand {
         "Insert symbols for active tab".into()
     }
 
+    fn icon(&self) -> IconName {
+        IconName::ListTree
+    }
+
     fn menu_text(&self) -> String {
         self.description()
     }

crates/assistant/src/slash_command/tab_command.rs

@@ -12,7 +12,7 @@ use std::{
     path::PathBuf,
     sync::{atomic::AtomicBool, Arc},
 };
-use ui::{ActiveTheme, WindowContext};
+use ui::{prelude::*, ActiveTheme, WindowContext};
 use util::ResultExt;
 use workspace::Workspace;
 
@@ -31,6 +31,10 @@ impl SlashCommand for TabSlashCommand {
         "Insert open tabs (active tab by default)".to_owned()
     }
 
+    fn icon(&self) -> IconName {
+        IconName::FileTree
+    }
+
     fn menu_text(&self) -> String {
         self.description()
     }

crates/assistant/src/slash_command/terminal_command.rs

@@ -33,6 +33,10 @@ impl SlashCommand for TerminalSlashCommand {
         "Insert terminal output".into()
     }
 
+    fn icon(&self) -> IconName {
+        IconName::Terminal
+    }
+
     fn menu_text(&self) -> String {
         self.description()
     }

crates/assistant/src/slash_command/workflow_command.rs

@@ -1,82 +0,0 @@
-use std::sync::atomic::AtomicBool;
-use std::sync::Arc;
-
-use anyhow::Result;
-use assistant_slash_command::{
-    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
-    SlashCommandResult,
-};
-use gpui::{Task, WeakView};
-use language::{BufferSnapshot, LspAdapterDelegate};
-use ui::prelude::*;
-use workspace::Workspace;
-
-use crate::prompts::PromptBuilder;
-
-pub(crate) struct WorkflowSlashCommand {
-    prompt_builder: Arc<PromptBuilder>,
-}
-
-impl WorkflowSlashCommand {
-    pub const NAME: &'static str = "workflow";
-
-    pub fn new(prompt_builder: Arc<PromptBuilder>) -> Self {
-        Self { prompt_builder }
-    }
-}
-
-impl SlashCommand for WorkflowSlashCommand {
-    fn name(&self) -> String {
-        Self::NAME.into()
-    }
-
-    fn description(&self) -> String {
-        "Insert prompt to opt into the edit workflow".into()
-    }
-
-    fn menu_text(&self) -> String {
-        self.description()
-    }
-
-    fn requires_argument(&self) -> bool {
-        false
-    }
-
-    fn complete_argument(
-        self: Arc<Self>,
-        _arguments: &[String],
-        _cancel: Arc<AtomicBool>,
-        _workspace: Option<WeakView<Workspace>>,
-        _cx: &mut WindowContext,
-    ) -> Task<Result<Vec<ArgumentCompletion>>> {
-        Task::ready(Ok(Vec::new()))
-    }
-
-    fn run(
-        self: Arc<Self>,
-        _arguments: &[String],
-        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
-        _context_buffer: BufferSnapshot,
-        _workspace: WeakView<Workspace>,
-        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
-        cx: &mut WindowContext,
-    ) -> Task<SlashCommandResult> {
-        let prompt_builder = self.prompt_builder.clone();
-        cx.spawn(|_cx| async move {
-            let text = prompt_builder.generate_workflow_prompt()?;
-            let range = 0..text.len();
-
-            Ok(SlashCommandOutput {
-                text,
-                sections: vec![SlashCommandOutputSection {
-                    range,
-                    icon: IconName::Route,
-                    label: "Workflow".into(),
-                    metadata: None,
-                }],
-                run_commands_in_text: false,
-            }
-            .to_event_stream())
-        })
-    }
-}

crates/assistant/src/slash_command_picker.rs

@@ -1,17 +1,10 @@
 use std::sync::Arc;
 
 use assistant_slash_command::SlashCommandRegistry;
-use gpui::AnyElement;
-use gpui::DismissEvent;
-use gpui::WeakView;
-use picker::PickerEditorPosition;
 
-use ui::ListItemSpacing;
-
-use gpui::SharedString;
-use gpui::Task;
-use picker::{Picker, PickerDelegate};
-use ui::{prelude::*, ListItem, PopoverMenu, PopoverTrigger};
+use gpui::{AnyElement, DismissEvent, SharedString, Task, WeakView};
+use picker::{Picker, PickerDelegate, PickerEditorPosition};
+use ui::{prelude::*, ListItem, ListItemSpacing, PopoverMenu, PopoverTrigger};
 
 use crate::assistant_panel::ContextEditor;
 
@@ -27,6 +20,7 @@ struct SlashCommandInfo {
     name: SharedString,
     description: SharedString,
     args: Option<SharedString>,
+    icon: IconName,
 }
 
 #[derive(Clone)]
@@ -145,16 +139,20 @@ impl PickerDelegate for SlashCommandDelegate {
         }
         ret
     }
+
     fn confirm(&mut self, _secondary: bool, cx: &mut ViewContext<Picker<Self>>) {
         if let Some(command) = self.filtered_commands.get(self.selected_index) {
-            if let SlashCommandEntry::Info(info) = command {
-                self.active_context_editor
-                    .update(cx, |context_editor, cx| {
-                        context_editor.insert_command(&info.name, cx)
-                    })
-                    .ok();
-            } else if let SlashCommandEntry::Advert { on_confirm, .. } = command {
-                on_confirm(cx);
+            match command {
+                SlashCommandEntry::Info(info) => {
+                    self.active_context_editor
+                        .update(cx, |context_editor, cx| {
+                            context_editor.insert_command(&info.name, cx)
+                        })
+                        .ok();
+                }
+                SlashCommandEntry::Advert { on_confirm, .. } => {
+                    on_confirm(cx);
+                }
             }
             cx.emit(DismissEvent);
         }
@@ -181,43 +179,41 @@ impl PickerDelegate for SlashCommandDelegate {
                     .spacing(ListItemSpacing::Dense)
                     .selected(selected)
                     .child(
-                        h_flex()
+                        v_flex()
                             .group(format!("command-entry-label-{ix}"))
                             .w_full()
                             .min_w(px(250.))
                             .child(
-                                v_flex()
-                                    .child(
-                                        h_flex()
-                                            .child(div().font_buffer(cx).child({
-                                                let mut label = format!("/{}", info.name);
-                                                if let Some(args) =
-                                                    info.args.as_ref().filter(|_| selected)
-                                                {
-                                                    label.push_str(&args);
-                                                }
-                                                Label::new(label).size(LabelSize::Small)
-                                            }))
-                                            .children(info.args.clone().filter(|_| !selected).map(
-                                                |args| {
-                                                    div()
-                                                        .font_buffer(cx)
-                                                        .child(
-                                                            Label::new(args)
-                                                                .size(LabelSize::Small)
-                                                                .color(Color::Muted),
-                                                        )
-                                                        .visible_on_hover(format!(
-                                                            "command-entry-label-{ix}"
-                                                        ))
-                                                },
-                                            )),
-                                    )
-                                    .child(
-                                        Label::new(info.description.clone())
-                                            .size(LabelSize::Small)
-                                            .color(Color::Muted),
-                                    ),
+                                h_flex()
+                                    .gap_1p5()
+                                    .child(Icon::new(info.icon).size(IconSize::XSmall))
+                                    .child(div().font_buffer(cx).child({
+                                        let mut label = format!("{}", info.name);
+                                        if let Some(args) = info.args.as_ref().filter(|_| selected)
+                                        {
+                                            label.push_str(&args);
+                                        }
+                                        Label::new(label).size(LabelSize::Small)
+                                    }))
+                                    .children(info.args.clone().filter(|_| !selected).map(
+                                        |args| {
+                                            div()
+                                                .font_buffer(cx)
+                                                .child(
+                                                    Label::new(args)
+                                                        .size(LabelSize::Small)
+                                                        .color(Color::Muted),
+                                                )
+                                                .visible_on_hover(format!(
+                                                    "command-entry-label-{ix}"
+                                                ))
+                                        },
+                                    )),
+                            )
+                            .child(
+                                Label::new(info.description.clone())
+                                    .size(LabelSize::Small)
+                                    .color(Color::Muted),
                             ),
                     ),
             ),
@@ -251,24 +247,40 @@ impl<T: PopoverTrigger> RenderOnce for SlashCommandSelector<T> {
                     name: command_name.into(),
                     description: menu_text,
                     args,
+                    icon: command.icon(),
                 }))
             })
             .chain([SlashCommandEntry::Advert {
                 name: "create-your-command".into(),
                 renderer: |cx| {
                     v_flex()
+                        .w_full()
                         .child(
                             h_flex()
+                                .w_full()
                                 .font_buffer(cx)
                                 .items_center()
-                                .gap_1()
-                                .child(div().font_buffer(cx).child(
-                                    Label::new("create-your-command").size(LabelSize::Small),
-                                ))
-                                .child(Icon::new(IconName::ArrowUpRight).size(IconSize::XSmall)),
+                                .justify_between()
+                                .child(
+                                    h_flex()
+                                        .items_center()
+                                        .gap_1p5()
+                                        .child(Icon::new(IconName::Plus).size(IconSize::XSmall))
+                                        .child(
+                                            div().font_buffer(cx).child(
+                                                Label::new("create-your-command")
+                                                    .size(LabelSize::Small),
+                                            ),
+                                        ),
+                                )
+                                .child(
+                                    Icon::new(IconName::ArrowUpRight)
+                                        .size(IconSize::XSmall)
+                                        .color(Color::Muted),
+                                ),
                         )
                         .child(
-                            Label::new("Learn how to create a custom command")
+                            Label::new("Create your custom command")
                                 .size(LabelSize::Small)
                                 .color(Color::Muted),
                         )

crates/assistant/src/streaming_diff.rs

@@ -28,13 +28,36 @@ impl Matrix {
         self.cols = cols;
     }
 
+    fn swap_columns(&mut self, col1: usize, col2: usize) {
+        if col1 == col2 {
+            return;
+        }
+
+        if col1 >= self.cols {
+            panic!("column out of bounds");
+        }
+
+        if col2 >= self.cols {
+            panic!("column out of bounds");
+        }
+
+        unsafe {
+            let ptr = self.cells.as_mut_ptr();
+            std::ptr::swap_nonoverlapping(
+                ptr.add(col1 * self.rows),
+                ptr.add(col2 * self.rows),
+                self.rows,
+            );
+        }
+    }
+
     fn get(&self, row: usize, col: usize) -> f64 {
         if row >= self.rows {
             panic!("row out of bounds")
         }
 
         if col >= self.cols {
-            panic!("col out of bounds")
+            panic!("column out of bounds")
         }
         self.cells[col * self.rows + row]
     }
@@ -45,7 +68,7 @@ impl Matrix {
         }
 
         if col >= self.cols {
-            panic!("col out of bounds")
+            panic!("column out of bounds")
         }
 
         self.cells[col * self.rows + row] = value;
@@ -106,26 +129,32 @@ impl StreamingDiff {
 
     pub fn push_new(&mut self, text: &str) -> Vec<CharOperation> {
         self.new.extend(text.chars());
-        self.scores.resize(self.old.len() + 1, self.new.len() + 1);
+        self.scores.swap_columns(0, self.scores.cols - 1);
+        self.scores
+            .resize(self.old.len() + 1, self.new.len() - self.new_text_ix + 1);
+        self.equal_runs.retain(|(_i, j), _| *j == self.new_text_ix);
 
         for j in self.new_text_ix + 1..=self.new.len() {
-            self.scores.set(0, j, j as f64 * Self::INSERTION_SCORE);
+            let relative_j = j - self.new_text_ix;
+
+            self.scores
+                .set(0, relative_j, j as f64 * Self::INSERTION_SCORE);
             for i in 1..=self.old.len() {
-                let insertion_score = self.scores.get(i, j - 1) + Self::INSERTION_SCORE;
-                let deletion_score = self.scores.get(i - 1, j) + Self::DELETION_SCORE;
+                let insertion_score = self.scores.get(i, relative_j - 1) + Self::INSERTION_SCORE;
+                let deletion_score = self.scores.get(i - 1, relative_j) + Self::DELETION_SCORE;
                 let equality_score = if self.old[i - 1] == self.new[j - 1] {
                     let mut equal_run = self.equal_runs.get(&(i - 1, j - 1)).copied().unwrap_or(0);
                     equal_run += 1;
                     self.equal_runs.insert((i, j), equal_run);
 
                     let exponent = cmp::min(equal_run as i32 / 4, Self::MAX_EQUALITY_EXPONENT);
-                    self.scores.get(i - 1, j - 1) + Self::EQUALITY_BASE.powi(exponent)
+                    self.scores.get(i - 1, relative_j - 1) + Self::EQUALITY_BASE.powi(exponent)
                 } else {
                     f64::NEG_INFINITY
                 };
 
                 let score = insertion_score.max(deletion_score).max(equality_score);
-                self.scores.set(i, j, score);
+                self.scores.set(i, relative_j, score);
             }
         }
 
@@ -133,7 +162,7 @@ impl StreamingDiff {
         let mut next_old_text_ix = self.old_text_ix;
         let next_new_text_ix = self.new.len();
         for i in self.old_text_ix..=self.old.len() {
-            let score = self.scores.get(i, next_new_text_ix);
+            let score = self.scores.get(i, next_new_text_ix - self.new_text_ix);
             if score > max_score {
                 max_score = score;
                 next_old_text_ix = i;
@@ -174,7 +203,9 @@ impl StreamingDiff {
 
             let (prev_i, prev_j) = [insertion_score, deletion_score, equality_score]
                 .iter()
-                .max_by_key(|cell| cell.map(|(i, j)| OrderedFloat(self.scores.get(i, j))))
+                .max_by_key(|cell| {
+                    cell.map(|(i, j)| OrderedFloat(self.scores.get(i, j - self.new_text_ix)))
+                })
                 .unwrap()
                 .unwrap();
 

crates/assistant/src/terminal_inline_assistant.rs

@@ -1,6 +1,6 @@
 use crate::{
     humanize_token_count, prompts::PromptBuilder, AssistantPanel, AssistantPanelEvent,
-    ModelSelector, DEFAULT_CONTEXT_LINES,
+    ModelSelector, RequestType, DEFAULT_CONTEXT_LINES,
 };
 use anyhow::{Context as _, Result};
 use client::telemetry::Telemetry;
@@ -17,7 +17,8 @@ use gpui::{
 };
 use language::Buffer;
 use language_model::{
-    LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage, Role,
+    logging::report_assistant_event, LanguageModelRegistry, LanguageModelRequest,
+    LanguageModelRequestMessage, Role,
 };
 use settings::Settings;
 use std::{
@@ -251,7 +252,7 @@ impl TerminalInlineAssistant {
                         .read(cx)
                         .active_context(cx)?
                         .read(cx)
-                        .to_completion_request(cx),
+                        .to_completion_request(RequestType::Chat, cx),
                 )
             })
         } else {
@@ -306,6 +307,33 @@ impl TerminalInlineAssistant {
                     this.focus_handle(cx).focus(cx);
                 })
                 .log_err();
+
+            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(
+                    AssistantEvent {
+                        conversation_id: None,
+                        kind: AssistantKind::InlineTerminal,
+                        message_id: codegen.message_id.clone(),
+                        phase: if undo {
+                            AssistantPhase::Rejected
+                        } else {
+                            AssistantPhase::Accepted
+                        },
+                        model: model.telemetry_id(),
+                        model_provider: model.provider_id().to_string(),
+                        response_latency: None,
+                        error_message: None,
+                        language_name: None,
+                    },
+                    codegen.telemetry.clone(),
+                    cx.http_client(),
+                    model.api_key(cx),
+                    &executor,
+                );
+            }
+
             assist.codegen.update(cx, |codegen, cx| {
                 if undo {
                     codegen.undo(cx);
@@ -1016,6 +1044,7 @@ pub struct Codegen {
     telemetry: Option<Arc<Telemetry>>,
     terminal: Model<Terminal>,
     generation: Task<()>,
+    message_id: Option<String>,
     transaction: Option<TerminalTransaction>,
 }
 
@@ -1026,6 +1055,7 @@ impl Codegen {
             telemetry,
             status: CodegenStatus::Idle,
             generation: Task::ready(()),
+            message_id: None,
             transaction: None,
         }
     }
@@ -1035,6 +1065,8 @@ impl Codegen {
             return;
         };
 
+        let model_api_key = model.api_key(cx);
+        let http_client = cx.http_client();
         let telemetry = self.telemetry.clone();
         self.status = CodegenStatus::Pending;
         self.transaction = Some(TerminalTransaction::start(self.terminal.clone()));
@@ -1043,44 +1075,62 @@ impl Codegen {
             let model_provider_id = model.provider_id();
             let response = model.stream_completion_text(prompt, &cx).await;
             let generate = async {
+                let message_id = response
+                    .as_ref()
+                    .ok()
+                    .and_then(|response| response.message_id.clone());
+
                 let (mut hunks_tx, mut hunks_rx) = mpsc::channel(1);
 
-                let task = cx.background_executor().spawn(async move {
-                    let mut response_latency = None;
-                    let request_start = Instant::now();
-                    let task = async {
-                        let mut chunks = response?;
-                        while let Some(chunk) = chunks.next().await {
-                            if response_latency.is_none() {
-                                response_latency = Some(request_start.elapsed());
+                let task = cx.background_executor().spawn({
+                    let message_id = message_id.clone();
+                    let executor = cx.background_executor().clone();
+                    async move {
+                        let mut response_latency = None;
+                        let request_start = Instant::now();
+                        let task = async {
+                            let mut chunks = response?.stream;
+                            while let Some(chunk) = chunks.next().await {
+                                if response_latency.is_none() {
+                                    response_latency = Some(request_start.elapsed());
+                                }
+                                let chunk = chunk?;
+                                hunks_tx.send(chunk).await?;
                             }
-                            let chunk = chunk?;
-                            hunks_tx.send(chunk).await?;
-                        }
 
+                            anyhow::Ok(())
+                        };
+
+                        let result = task.await;
+
+                        let error_message = result.as_ref().err().map(|error| error.to_string());
+                        report_assistant_event(
+                            AssistantEvent {
+                                conversation_id: None,
+                                kind: AssistantKind::InlineTerminal,
+                                message_id,
+                                phase: AssistantPhase::Response,
+                                model: model_telemetry_id,
+                                model_provider: model_provider_id.to_string(),
+                                response_latency,
+                                error_message,
+                                language_name: None,
+                            },
+                            telemetry,
+                            http_client,
+                            model_api_key,
+                            &executor,
+                        );
+
+                        result?;
                         anyhow::Ok(())
-                    };
-
-                    let result = task.await;
-
-                    let error_message = result.as_ref().err().map(|error| error.to_string());
-                    if let Some(telemetry) = telemetry {
-                        telemetry.report_assistant_event(AssistantEvent {
-                            conversation_id: None,
-                            kind: AssistantKind::Inline,
-                            phase: AssistantPhase::Response,
-                            model: model_telemetry_id,
-                            model_provider: model_provider_id.to_string(),
-                            response_latency,
-                            error_message,
-                            language_name: None,
-                        });
                     }
-
-                    result?;
-                    anyhow::Ok(())
                 });
 
+                this.update(&mut cx, |this, _| {
+                    this.message_id = message_id;
+                })?;
+
                 while let Some(hunk) = hunks_rx.next().await {
                     this.update(&mut cx, |this, cx| {
                         if let Some(transaction) = &mut this.transaction {

crates/assistant/src/tools.rs

@@ -1 +1,2 @@
+pub mod context_server_tool;
 pub mod now_tool;

crates/assistant/src/tools/context_server_tool.rs

@@ -0,0 +1,82 @@
+use anyhow::{anyhow, bail};
+use assistant_tool::Tool;
+use context_servers::manager::ContextServerManager;
+use context_servers::types;
+use gpui::Task;
+
+pub struct ContextServerTool {
+    server_id: String,
+    tool: types::Tool,
+}
+
+impl ContextServerTool {
+    pub fn new(server_id: impl Into<String>, tool: types::Tool) -> Self {
+        Self {
+            server_id: server_id.into(),
+            tool,
+        }
+    }
+}
+
+impl Tool for ContextServerTool {
+    fn name(&self) -> String {
+        self.tool.name.clone()
+    }
+
+    fn description(&self) -> String {
+        self.tool.description.clone().unwrap_or_default()
+    }
+
+    fn input_schema(&self) -> serde_json::Value {
+        match &self.tool.input_schema {
+            serde_json::Value::Null => {
+                serde_json::json!({ "type": "object", "properties": [] })
+            }
+            serde_json::Value::Object(map) if map.is_empty() => {
+                serde_json::json!({ "type": "object", "properties": [] })
+            }
+            _ => self.tool.input_schema.clone(),
+        }
+    }
+
+    fn run(
+        self: std::sync::Arc<Self>,
+        input: serde_json::Value,
+        _workspace: gpui::WeakView<workspace::Workspace>,
+        cx: &mut ui::WindowContext,
+    ) -> gpui::Task<gpui::Result<String>> {
+        let manager = ContextServerManager::global(cx);
+        let manager = manager.read(cx);
+        if let Some(server) = manager.get_server(&self.server_id) {
+            cx.foreground_executor().spawn({
+                let tool_name = self.tool.name.clone();
+                async move {
+                    let Some(protocol) = server.client.read().clone() else {
+                        bail!("Context server not initialized");
+                    };
+
+                    let arguments = if let serde_json::Value::Object(map) = input {
+                        Some(map.into_iter().collect())
+                    } else {
+                        None
+                    };
+
+                    log::trace!(
+                        "Running tool: {} with arguments: {:?}",
+                        tool_name,
+                        arguments
+                    );
+                    let response = protocol.run_tool(tool_name, arguments).await?;
+
+                    let tool_result = match response.tool_result {
+                        serde_json::Value::String(s) => s,
+                        _ => serde_json::to_string(&response.tool_result)?,
+                    };
+                    Ok(tool_result)
+                }
+            })
+        } else {
+            Task::ready(Err(anyhow!("Context server not found")))
+        }
+    }
+}

crates/assistant_slash_command/Cargo.toml

@@ -18,6 +18,7 @@ derive_more.workspace = true
 futures.workspace = true
 gpui.workspace = true
 language.workspace = true
+language_model.workspace = true
 parking_lot.workspace = true
 serde.workspace = true
 serde_json.workspace = true

crates/assistant_slash_command/src/assistant_slash_command.rs

@@ -5,6 +5,7 @@ use futures::stream::{self, BoxStream};
 use futures::StreamExt;
 use gpui::{AnyElement, AppContext, ElementId, SharedString, Task, WeakView, WindowContext};
 use language::{BufferSnapshot, CodeLabel, LspAdapterDelegate, OffsetRangeExt};
+pub use language_model::Role;
 use serde::{Deserialize, Serialize};
 pub use slash_command_registry::*;
 use std::{
@@ -62,6 +63,9 @@ pub type SlashCommandResult = Result<BoxStream<'static, Result<SlashCommandEvent
 
 pub trait SlashCommand: 'static + Send + Sync {
     fn name(&self) -> String;
+    fn icon(&self) -> IconName {
+        IconName::Slash
+    }
     fn label(&self, _cx: &AppContext) -> CodeLabel {
         CodeLabel::plain(self.name(), None)
     }
@@ -100,7 +104,7 @@ pub type RenderFoldPlaceholder = Arc<
         + Fn(ElementId, Arc<dyn Fn(&mut WindowContext)>, &mut WindowContext) -> AnyElement,
 >;
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq)]
 pub enum SlashCommandContent {
     Text {
         text: String,
@@ -108,8 +112,21 @@ pub enum SlashCommandContent {
     },
 }
 
-#[derive(Debug, PartialEq, Eq)]
+impl<'a> From<&'a str> for SlashCommandContent {
+    fn from(text: &'a str) -> Self {
+        Self::Text {
+            text: text.into(),
+            run_commands_in_text: false,
+        }
+    }
+}
+
+#[derive(Debug, PartialEq)]
 pub enum SlashCommandEvent {
+    StartMessage {
+        role: Role,
+        merge_same_roles: bool,
+    },
     StartSection {
         icon: IconName,
         label: SharedString,
@@ -229,6 +246,7 @@ impl SlashCommandOutput {
                         output.sections.push(section);
                     }
                 }
+                SlashCommandEvent::StartMessage { .. } => {}
             }
         }
 

crates/auto_update/src/auto_update.rs

@@ -84,9 +84,9 @@ pub struct AutoUpdater {
 }
 
 #[derive(Deserialize)]
-struct JsonRelease {
-    version: String,
-    url: String,
+pub struct JsonRelease {
+    pub version: String,
+    pub url: String,
 }
 
 struct MacOsUnmounter {
@@ -432,6 +432,9 @@ impl AutoUpdater {
         cx.notify();
     }
 
+    // If you are packaging Zed and need to override the place it downloads SSH remotes from,
+    // you can override this function. You should also update get_remote_server_release_url to return
+    // Ok(None).
     pub async fn download_remote_server_release(
         os: &str,
         arch: &str,
@@ -482,7 +485,7 @@ impl AutoUpdater {
         release_channel: ReleaseChannel,
         version: Option<SemanticVersion>,
         cx: &mut AsyncAppContext,
-    ) -> Result<(String, String)> {
+    ) -> Result<Option<(String, String)>> {
         let this = cx.update(|cx| {
             cx.default_global::<GlobalAutoUpdate>()
                 .0
@@ -504,7 +507,7 @@ impl AutoUpdater {
         let update_request_body = build_remote_server_update_request_body(cx)?;
         let body = serde_json::to_string(&update_request_body)?;
 
-        Ok((release.url, body))
+        Ok(Some((release.url, body)))
     }
 
     async fn get_release(
@@ -686,6 +689,12 @@ async fn download_remote_server_binary(
     let request_body = AsyncBody::from(serde_json::to_string(&update_request_body)?);
 
     let mut response = client.get(&release.url, request_body, true).await?;
+    if !response.status().is_success() {
+        return Err(anyhow!(
+            "failed to download remote server release: {:?}",
+            response.status()
+        ));
+    }
     smol::io::copy(response.body_mut(), &mut temp_file).await?;
     smol::fs::rename(&temp, &target_path).await?;
 

crates/call/Cargo.toml

@@ -13,7 +13,6 @@ path = "src/call.rs"
 doctest = false
 
 [features]
-no-webrtc = ["live_kit_client/no-webrtc"]
 test-support = [
     "client/test-support",
     "collections/test-support",

crates/client/Cargo.toml

@@ -44,7 +44,6 @@ sha2.workspace = true
 smol.workspace = true
 sysinfo.workspace = true
 telemetry_events.workspace = true
-tempfile.workspace = true
 text.workspace = true
 thiserror.workspace = true
 time.workspace = true

crates/client/src/telemetry.rs

@@ -13,6 +13,7 @@ use parking_lot::Mutex;
 use release_channel::ReleaseChannel;
 use settings::{Settings, SettingsStore};
 use sha2::{Digest, Sha256};
+use std::fs::File;
 use std::io::Write;
 use std::{env, mem, path::PathBuf, sync::Arc, time::Duration};
 use sysinfo::{CpuRefreshKind, Pid, ProcessRefreshKind, RefreshKind, System};
@@ -21,10 +22,7 @@ use telemetry_events::{
     EventRequestBody, EventWrapper, ExtensionEvent, InlineCompletionEvent, MemoryEvent, ReplEvent,
     SettingEvent,
 };
-use tempfile::NamedTempFile;
-#[cfg(not(debug_assertions))]
-use util::ResultExt;
-use util::TryFutureExt;
+use util::{ResultExt, TryFutureExt};
 use worktree::{UpdatedEntriesSet, WorktreeId};
 
 use self::event_coalescer::EventCoalescer;
@@ -46,7 +44,7 @@ struct TelemetryState {
     architecture: &'static str,
     events_queue: Vec<EventWrapper>,
     flush_events_task: Option<Task<()>>,
-    log_file: Option<NamedTempFile>,
+    log_file: Option<File>,
     is_staff: Option<bool>,
     first_event_date_time: Option<DateTime<Utc>>,
     event_coalescer: EventCoalescer,
@@ -223,15 +221,13 @@ impl Telemetry {
             os_name: os_name(),
             app_version: release_channel::AppVersion::global(cx).to_string(),
         }));
+        Self::log_file_path();
 
-        #[cfg(not(debug_assertions))]
         cx.background_executor()
             .spawn({
                 let state = state.clone();
                 async move {
-                    if let Some(tempfile) =
-                        NamedTempFile::new_in(paths::logs_dir().as_path()).log_err()
-                    {
+                    if let Some(tempfile) = File::create(Self::log_file_path()).log_err() {
                         state.lock().log_file = Some(tempfile);
                     }
                 }
@@ -280,8 +276,8 @@ impl Telemetry {
         Task::ready(())
     }
 
-    pub fn log_file_path(&self) -> Option<PathBuf> {
-        Some(self.state.lock().log_file.as_ref()?.path().to_path_buf())
+    pub fn log_file_path() -> PathBuf {
+        paths::logs_dir().join("telemetry.log")
     }
 
     pub fn start(
@@ -341,6 +337,13 @@ impl Telemetry {
             .detach();
     }
 
+    pub fn metrics_enabled(self: &Arc<Self>) -> bool {
+        let state = self.state.lock();
+        let enabled = state.settings.metrics;
+        drop(state);
+        return enabled;
+    }
+
     pub fn set_authenticated_user_info(
         self: &Arc<Self>,
         metrics_id: Option<String>,
@@ -638,7 +641,6 @@ impl Telemetry {
                     let mut json_bytes = Vec::new();
 
                     if let Some(file) = &mut this.state.lock().log_file {
-                        let file = file.as_file_mut();
                         for event in &mut events {
                             json_bytes.clear();
                             serde_json::to_writer(&mut json_bytes, event)?;

crates/client/src/user.rs

@@ -48,6 +48,7 @@ pub struct Collaborator {
     pub peer_id: proto::PeerId,
     pub replica_id: ReplicaId,
     pub user_id: UserId,
+    pub is_host: bool,
 }
 
 impl PartialOrd for User {
@@ -824,6 +825,7 @@ impl Collaborator {
             peer_id: message.peer_id.ok_or_else(|| anyhow!("invalid peer id"))?,
             replica_id: message.replica_id as ReplicaId,
             user_id: message.user_id as UserId,
+            is_host: message.is_host,
         })
     }
 }

crates/collab/migrations.sqlite/20221109000000_test_schema.sql

@@ -52,9 +52,7 @@ CREATE TABLE "projects" (
     "host_user_id" INTEGER REFERENCES users (id),
     "host_connection_id" INTEGER,
     "host_connection_server_id" INTEGER REFERENCES servers (id) ON DELETE CASCADE,
-    "unregistered" BOOLEAN NOT NULL DEFAULT FALSE,
-    "hosted_project_id" INTEGER REFERENCES hosted_projects (id),
-    "dev_server_project_id" INTEGER REFERENCES dev_server_projects(id)
+    "unregistered" BOOLEAN NOT NULL DEFAULT FALSE
 );
 CREATE INDEX "index_projects_on_host_connection_server_id" ON "projects" ("host_connection_server_id");
 CREATE INDEX "index_projects_on_host_connection_id_and_host_connection_server_id" ON "projects" ("host_connection_id", "host_connection_server_id");
@@ -399,30 +397,6 @@ CREATE TABLE rate_buckets (
 );
 CREATE INDEX idx_user_id_rate_limit ON rate_buckets (user_id, rate_limit_name);
 
-CREATE TABLE hosted_projects (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    channel_id INTEGER NOT NULL REFERENCES channels(id),
-    name TEXT NOT NULL,
-    visibility TEXT NOT NULL,
-    deleted_at TIMESTAMP NULL
-);
-CREATE INDEX idx_hosted_projects_on_channel_id ON hosted_projects (channel_id);
-CREATE UNIQUE INDEX uix_hosted_projects_on_channel_id_and_name ON hosted_projects (channel_id, name) WHERE (deleted_at IS NULL);
-
-CREATE TABLE dev_servers (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    user_id INTEGER NOT NULL REFERENCES users(id),
-    name TEXT NOT NULL,
-    ssh_connection_string TEXT,
-    hashed_token TEXT NOT NULL
-);
-
-CREATE TABLE dev_server_projects (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    dev_server_id INTEGER NOT NULL REFERENCES dev_servers(id),
-    paths TEXT NOT NULL
-);
-
 CREATE TABLE IF NOT EXISTS billing_preferences (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,

crates/collab/migrations/20241023201725_remove_dev_servers.sql

@@ -0,0 +1,6 @@
+ALTER TABLE projects DROP COLUMN dev_server_project_id;
+ALTER TABLE projects DROP COLUMN hosted_project_id;
+
+DROP TABLE hosted_projects;
+DROP TABLE dev_server_projects;
+DROP TABLE dev_servers;

crates/collab/src/db.rs

@@ -740,6 +740,7 @@ impl ProjectCollaborator {
             peer_id: Some(self.connection_id.into()),
             replica_id: self.replica_id.0 as u32,
             user_id: self.user_id.to_proto(),
+            is_host: self.is_host,
         }
     }
 }

crates/collab/src/db/queries/buffers.rs

@@ -116,6 +116,7 @@ impl Database {
                         peer_id: Some(collaborator.connection().into()),
                         user_id: collaborator.user_id.to_proto(),
                         replica_id: collaborator.replica_id.0 as u32,
+                        is_host: false,
                     })
                     .collect(),
             })
@@ -222,6 +223,7 @@ impl Database {
                                 peer_id: Some(collaborator.connection().into()),
                                 user_id: collaborator.user_id.to_proto(),
                                 replica_id: collaborator.replica_id.0 as u32,
+                                is_host: false,
                             })
                             .collect(),
                     },
@@ -257,6 +259,7 @@ impl Database {
                         peer_id: Some(db_collaborator.connection().into()),
                         replica_id: db_collaborator.replica_id.0 as u32,
                         user_id: db_collaborator.user_id.to_proto(),
+                        is_host: false,
                     })
                 } else {
                     collaborator_ids_to_remove.push(db_collaborator.id);
@@ -385,6 +388,7 @@ impl Database {
                 peer_id: Some(connection.into()),
                 replica_id: row.replica_id.0 as u32,
                 user_id: row.user_id.to_proto(),
+                is_host: false,
             });
         }
 

crates/collab/src/db/queries/projects.rs

@@ -750,49 +750,6 @@ impl Database {
         Ok((project, replica_id as ReplicaId))
     }
 
-    pub async fn leave_hosted_project(
-        &self,
-        project_id: ProjectId,
-        connection: ConnectionId,
-    ) -> Result<LeftProject> {
-        self.transaction(|tx| async move {
-            let result = project_collaborator::Entity::delete_many()
-                .filter(
-                    Condition::all()
-                        .add(project_collaborator::Column::ProjectId.eq(project_id))
-                        .add(project_collaborator::Column::ConnectionId.eq(connection.id as i32))
-                        .add(
-                            project_collaborator::Column::ConnectionServerId
-                                .eq(connection.owner_id as i32),
-                        ),
-                )
-                .exec(&*tx)
-                .await?;
-            if result.rows_affected == 0 {
-                return Err(anyhow!("not in the project"))?;
-            }
-
-            let project = project::Entity::find_by_id(project_id)
-                .one(&*tx)
-                .await?
-                .ok_or_else(|| anyhow!("no such project"))?;
-            let collaborators = project
-                .find_related(project_collaborator::Entity)
-                .all(&*tx)
-                .await?;
-            let connection_ids = collaborators
-                .into_iter()
-                .map(|collaborator| collaborator.connection())
-                .collect();
-            Ok(LeftProject {
-                id: project.id,
-                connection_ids,
-                should_unshare: false,
-            })
-        })
-        .await
-    }
-
     /// Removes the given connection from the specified project.
     pub async fn leave_project(
         &self,

crates/collab/src/db/tests/buffer_tests.rs

@@ -121,11 +121,13 @@ async fn test_channel_buffers(db: &Arc<Database>) {
                 user_id: a_id.to_proto(),
                 peer_id: Some(rpc::proto::PeerId { id: 1, owner_id }),
                 replica_id: 0,
+                is_host: false,
             },
             rpc::proto::Collaborator {
                 user_id: b_id.to_proto(),
                 peer_id: Some(rpc::proto::PeerId { id: 2, owner_id }),
                 replica_id: 1,
+                is_host: false,
             }
         ]
     );

crates/collab/src/llm.rs

@@ -449,6 +449,10 @@ async fn check_usage_limit(
     model_name: &str,
     claims: &LlmTokenClaims,
 ) -> Result<()> {
+    if claims.is_staff {
+        return Ok(());
+    }
+
     let model = state.db.model(provider, model_name)?;
     let usage = state
         .db
@@ -513,11 +517,6 @@ async fn check_usage_limit(
     ];
 
     for (used, limit, usage_measure) in checks {
-        // Temporarily bypass rate-limiting for staff members.
-        if claims.is_staff {
-            continue;
-        }
-
         if used > limit {
             let resource = match usage_measure {
                 UsageMeasure::RequestsPerMinute => "requests_per_minute",

crates/collab/src/rpc.rs

@@ -1827,6 +1827,7 @@ fn join_project_internal(
             peer_id: Some(session.connection_id.into()),
             replica_id: replica_id.0 as u32,
             user_id: guest_user_id.to_proto(),
+            is_host: false,
         }),
     };
 

crates/collab/src/tests/editor_tests.rs

@@ -1978,6 +1978,7 @@ async fn test_git_blame_is_forwarded(cx_a: &mut TestAppContext, cx_b: &mut TestA
         enabled: false,
         delay_ms: None,
         min_column: None,
+        show_commit_summary: false,
     });
     cx_a.update(|cx| {
         SettingsStore::update_global(cx, |store, cx| {

crates/collab/src/tests/following_tests.rs

@@ -1957,9 +1957,10 @@ async fn test_following_to_channel_notes_without_a_shared_project(
     });
     channel_notes_1_b.update(cx_b, |notes, cx| {
         assert_eq!(notes.channel(cx).unwrap().name, "channel-1");
-        let editor = notes.editor.read(cx);
-        assert_eq!(editor.text(cx), "Hello from A.");
-        assert_eq!(editor.selections.ranges::<usize>(cx), &[3..4]);
+        notes.editor.update(cx, |editor, cx| {
+            assert_eq!(editor.text(cx), "Hello from A.");
+            assert_eq!(editor.selections.ranges::<usize>(cx), &[3..4]);
+        })
     });
 
     //  Client A opens the notes for channel 2.

crates/collab/src/tests/integration_tests.rs

@@ -21,8 +21,8 @@ use language::{
     language_settings::{
         AllLanguageSettings, Formatter, FormatterList, PrettierSettings, SelectedFormatter,
     },
-    tree_sitter_rust, Diagnostic, DiagnosticEntry, FakeLspAdapter, Language, LanguageConfig,
-    LanguageMatcher, LineEnding, OffsetRangeExt, Point, Rope,
+    tree_sitter_rust, tree_sitter_typescript, Diagnostic, DiagnosticEntry, FakeLspAdapter,
+    Language, LanguageConfig, LanguageMatcher, LineEnding, OffsetRangeExt, Point, Rope,
 };
 use live_kit_client::MacOSDisplay;
 use lsp::LanguageServerId;
@@ -4461,7 +4461,7 @@ async fn test_prettier_formatting_buffer(
             },
             ..Default::default()
         },
-        Some(tree_sitter_rust::LANGUAGE.into()),
+        Some(tree_sitter_typescript::LANGUAGE_TYPESCRIPT.into()),
     )));
     let mut fake_language_servers = client_a.language_registry().register_fake_lsp(
         "TypeScript",
@@ -6497,7 +6497,7 @@ async fn test_context_collaboration_with_reconnect(
         .await
         .unwrap();
 
-    // Client A creates a new context.
+    // Client A creates a new chats.
     let context_a = context_store_a.update(cx_a, |store, cx| store.create(cx));
     executor.run_until_parked();
 

crates/collab/src/tests/remote_editing_collaboration_tests.rs

@@ -1,14 +1,27 @@
 use crate::tests::TestServer;
 use call::ActiveCall;
+use collections::HashSet;
 use fs::{FakeFs, Fs as _};
-use gpui::{BackgroundExecutor, Context as _, TestAppContext};
+use futures::StreamExt as _;
+use gpui::{BackgroundExecutor, Context as _, SemanticVersion, TestAppContext, UpdateGlobal as _};
 use http_client::BlockedHttpClient;
-use language::{language_settings::language_settings, LanguageRegistry};
+use language::{
+    language_settings::{
+        language_settings, AllLanguageSettings, Formatter, FormatterList, PrettierSettings,
+        SelectedFormatter,
+    },
+    tree_sitter_typescript, FakeLspAdapter, Language, LanguageConfig, LanguageMatcher,
+    LanguageRegistry,
+};
 use node_runtime::NodeRuntime;
-use project::ProjectPath;
+use project::{
+    lsp_store::{FormatTarget, FormatTrigger},
+    ProjectPath,
+};
 use remote::SshRemoteClient;
 use remote_server::{HeadlessAppState, HeadlessProject};
 use serde_json::json;
+use settings::SettingsStore;
 use std::{path::Path, sync::Arc};
 
 #[gpui::test(iterations = 10)]
@@ -18,6 +31,12 @@ async fn test_sharing_an_ssh_remote_project(
     server_cx: &mut TestAppContext,
 ) {
     let executor = cx_a.executor();
+    cx_a.update(|cx| {
+        release_channel::init(SemanticVersion::default(), cx);
+    });
+    server_cx.update(|cx| {
+        release_channel::init(SemanticVersion::default(), cx);
+    });
     let mut server = TestServer::start(executor.clone()).await;
     let client_a = server.create_client(cx_a, "user_a").await;
     let client_b = server.create_client(cx_b, "user_b").await;
@@ -186,6 +205,13 @@ async fn test_ssh_collaboration_git_branches(
     cx_b.set_name("b");
     server_cx.set_name("server");
 
+    cx_a.update(|cx| {
+        release_channel::init(SemanticVersion::default(), cx);
+    });
+    server_cx.update(|cx| {
+        release_channel::init(SemanticVersion::default(), cx);
+    });
+
     let mut server = TestServer::start(executor.clone()).await;
     let client_a = server.create_client(cx_a, "user_a").await;
     let client_b = server.create_client(cx_b, "user_b").await;
@@ -304,3 +330,188 @@ async fn test_ssh_collaboration_git_branches(
 
     assert_eq!(server_branch.as_ref(), "totally-new-branch");
 }
+
+#[gpui::test]
+async fn test_ssh_collaboration_formatting_with_prettier(
+    executor: BackgroundExecutor,
+    cx_a: &mut TestAppContext,
+    cx_b: &mut TestAppContext,
+    server_cx: &mut TestAppContext,
+) {
+    cx_a.set_name("a");
+    cx_b.set_name("b");
+    server_cx.set_name("server");
+
+    cx_a.update(|cx| {
+        release_channel::init(SemanticVersion::default(), cx);
+    });
+    server_cx.update(|cx| {
+        release_channel::init(SemanticVersion::default(), cx);
+    });
+
+    let mut server = TestServer::start(executor.clone()).await;
+    let client_a = server.create_client(cx_a, "user_a").await;
+    let client_b = server.create_client(cx_b, "user_b").await;
+    server
+        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
+        .await;
+
+    let (opts, server_ssh) = SshRemoteClient::fake_server(cx_a, server_cx);
+    let remote_fs = FakeFs::new(server_cx.executor());
+    let buffer_text = "let one = \"two\"";
+    let prettier_format_suffix = project::TEST_PRETTIER_FORMAT_SUFFIX;
+    remote_fs
+        .insert_tree("/project", serde_json::json!({ "a.ts": buffer_text }))
+        .await;
+
+    let test_plugin = "test_plugin";
+    let ts_lang = Arc::new(Language::new(
+        LanguageConfig {
+            name: "TypeScript".into(),
+            matcher: LanguageMatcher {
+                path_suffixes: vec!["ts".to_string()],
+                ..LanguageMatcher::default()
+            },
+            ..LanguageConfig::default()
+        },
+        Some(tree_sitter_typescript::LANGUAGE_TYPESCRIPT.into()),
+    ));
+    client_a.language_registry().add(ts_lang.clone());
+    client_b.language_registry().add(ts_lang.clone());
+
+    let languages = Arc::new(LanguageRegistry::new(server_cx.executor()));
+    let mut fake_language_servers = languages.register_fake_lsp(
+        "TypeScript",
+        FakeLspAdapter {
+            prettier_plugins: vec![test_plugin],
+            ..Default::default()
+        },
+    );
+
+    // User A connects to the remote project via SSH.
+    server_cx.update(HeadlessProject::init);
+    let remote_http_client = Arc::new(BlockedHttpClient);
+    let _headless_project = server_cx.new_model(|cx| {
+        client::init_settings(cx);
+        HeadlessProject::new(
+            HeadlessAppState {
+                session: server_ssh,
+                fs: remote_fs.clone(),
+                http_client: remote_http_client,
+                node_runtime: NodeRuntime::unavailable(),
+                languages,
+            },
+            cx,
+        )
+    });
+
+    let client_ssh = SshRemoteClient::fake_client(opts, cx_a).await;
+    let (project_a, worktree_id) = client_a
+        .build_ssh_project("/project", client_ssh, cx_a)
+        .await;
+
+    // While the SSH worktree is being scanned, user A shares the remote project.
+    let active_call_a = cx_a.read(ActiveCall::global);
+    let project_id = active_call_a
+        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
+        .await
+        .unwrap();
+
+    // User B joins the project.
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
+    executor.run_until_parked();
+
+    // Opens the buffer and formats it
+    let buffer_b = project_b
+        .update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.ts"), cx))
+        .await
+        .expect("user B opens buffer for formatting");
+
+    cx_a.update(|cx| {
+        SettingsStore::update_global(cx, |store, cx| {
+            store.update_user_settings::<AllLanguageSettings>(cx, |file| {
+                file.defaults.formatter = Some(SelectedFormatter::Auto);
+                file.defaults.prettier = Some(PrettierSettings {
+                    allowed: true,
+                    ..PrettierSettings::default()
+                });
+            });
+        });
+    });
+    cx_b.update(|cx| {
+        SettingsStore::update_global(cx, |store, cx| {
+            store.update_user_settings::<AllLanguageSettings>(cx, |file| {
+                file.defaults.formatter = Some(SelectedFormatter::List(FormatterList(
+                    vec![Formatter::LanguageServer { name: None }].into(),
+                )));
+                file.defaults.prettier = Some(PrettierSettings {
+                    allowed: true,
+                    ..PrettierSettings::default()
+                });
+            });
+        });
+    });
+    let fake_language_server = fake_language_servers.next().await.unwrap();
+    fake_language_server.handle_request::<lsp::request::Formatting, _, _>(|_, _| async move {
+        panic!(
+            "Unexpected: prettier should be preferred since it's enabled and language supports it"
+        )
+    });
+
+    project_b
+        .update(cx_b, |project, cx| {
+            project.format(
+                HashSet::from_iter([buffer_b.clone()]),
+                true,
+                FormatTrigger::Save,
+                FormatTarget::Buffer,
+                cx,
+            )
+        })
+        .await
+        .unwrap();
+
+    executor.run_until_parked();
+    assert_eq!(
+        buffer_b.read_with(cx_b, |buffer, _| buffer.text()),
+        buffer_text.to_string() + "\n" + prettier_format_suffix,
+        "Prettier formatting was not applied to client buffer after client's request"
+    );
+
+    // User A opens and formats the same buffer too
+    let buffer_a = project_a
+        .update(cx_a, |p, cx| p.open_buffer((worktree_id, "a.ts"), cx))
+        .await
+        .expect("user A opens buffer for formatting");
+
+    cx_a.update(|cx| {
+        SettingsStore::update_global(cx, |store, cx| {
+            store.update_user_settings::<AllLanguageSettings>(cx, |file| {
+                file.defaults.formatter = Some(SelectedFormatter::Auto);
+                file.defaults.prettier = Some(PrettierSettings {
+                    allowed: true,
+                    ..PrettierSettings::default()
+                });
+            });
+        });
+    });
+    project_a
+        .update(cx_a, |project, cx| {
+            project.format(
+                HashSet::from_iter([buffer_a.clone()]),
+                true,
+                FormatTrigger::Manual,
+                FormatTarget::Buffer,
+                cx,
+            )
+        })
+        .await
+        .unwrap();
+
+    executor.run_until_parked();
+    assert_eq!(
+        buffer_b.read_with(cx_b, |buffer, _| buffer.text()),
+        buffer_text.to_string() + "\n" + prettier_format_suffix + "\n" + prettier_format_suffix,
+        "Prettier formatting was not applied to client buffer after host's request"
+    );
+}

crates/collab_ui/src/collab_panel.rs

@@ -2726,7 +2726,7 @@ impl Render for CollabPanel {
             .on_action(cx.listener(CollabPanel::collapse_selected_channel))
             .on_action(cx.listener(CollabPanel::expand_selected_channel))
             .on_action(cx.listener(CollabPanel::start_move_selected_channel))
-            .track_focus(&self.focus_handle)
+            .track_focus(&self.focus_handle(cx))
             .size_full()
             .child(if self.user_store.read(cx).current_user().is_none() {
                 self.render_signed_out(cx)

crates/context_servers/src/protocol.rs

@@ -180,6 +180,39 @@ impl InitializedContextServerProtocol {
 
         Ok(completion)
     }
+
+    /// List MCP tools.
+    pub async fn list_tools(&self) -> Result<types::ListToolsResponse> {
+        self.check_capability(ServerCapability::Tools)?;
+
+        let response = self
+            .inner
+            .request::<types::ListToolsResponse>(types::RequestType::ListTools.as_str(), ())
+            .await?;
+
+        Ok(response)
+    }
+
+    /// Executes a tool with the given arguments
+    pub async fn run_tool<P: AsRef<str>>(
+        &self,
+        tool: P,
+        arguments: Option<HashMap<String, serde_json::Value>>,
+    ) -> Result<types::CallToolResponse> {
+        self.check_capability(ServerCapability::Tools)?;
+
+        let params = types::CallToolParams {
+            name: tool.as_ref().to_string(),
+            arguments,
+        };
+
+        let response: types::CallToolResponse = self
+            .inner
+            .request(types::RequestType::CallTool.as_str(), params)
+            .await?;
+
+        Ok(response)
+    }
 }
 
 impl InitializedContextServerProtocol {

crates/context_servers/src/registry.rs

@@ -9,7 +9,8 @@ struct GlobalContextServerRegistry(Arc<ContextServerRegistry>);
 impl Global for GlobalContextServerRegistry {}
 
 pub struct ContextServerRegistry {
-    registry: RwLock<HashMap<String, Vec<Arc<str>>>>,
+    command_registry: RwLock<HashMap<String, Vec<Arc<str>>>>,
+    tool_registry: RwLock<HashMap<String, Vec<Arc<str>>>>,
 }
 
 impl ContextServerRegistry {
@@ -20,13 +21,14 @@ impl ContextServerRegistry {
     pub fn register(cx: &mut AppContext) {
         cx.set_global(GlobalContextServerRegistry(Arc::new(
             ContextServerRegistry {
-                registry: RwLock::new(HashMap::default()),
+                command_registry: RwLock::new(HashMap::default()),
+                tool_registry: RwLock::new(HashMap::default()),
             },
         )))
     }
 
     pub fn register_command(&self, server_id: String, command_name: &str) {
-        let mut registry = self.registry.write();
+        let mut registry = self.command_registry.write();
         registry
             .entry(server_id)
             .or_default()
@@ -34,14 +36,34 @@ impl ContextServerRegistry {
     }
 
     pub fn unregister_command(&self, server_id: &str, command_name: &str) {
-        let mut registry = self.registry.write();
+        let mut registry = self.command_registry.write();
         if let Some(commands) = registry.get_mut(server_id) {
             commands.retain(|name| name.as_ref() != command_name);
         }
     }
 
     pub fn get_commands(&self, server_id: &str) -> Option<Vec<Arc<str>>> {
-        let registry = self.registry.read();
+        let registry = self.command_registry.read();
+        registry.get(server_id).cloned()
+    }
+
+    pub fn register_tool(&self, server_id: String, tool_name: &str) {
+        let mut registry = self.tool_registry.write();
+        registry
+            .entry(server_id)
+            .or_default()
+            .push(tool_name.into());
+    }
+
+    pub fn unregister_tool(&self, server_id: &str, tool_name: &str) {
+        let mut registry = self.tool_registry.write();
+        if let Some(tools) = registry.get_mut(server_id) {
+            tools.retain(|name| name.as_ref() != tool_name);
+        }
+    }
+
+    pub fn get_tools(&self, server_id: &str) -> Option<Vec<Arc<str>>> {
+        let registry = self.tool_registry.read();
         registry.get(server_id).cloned()
     }
 }

crates/context_servers/src/types.rs

@@ -16,6 +16,8 @@ pub enum RequestType {
     PromptsList,
     CompletionComplete,
     Ping,
+    ListTools,
+    ListResourceTemplates,
 }
 
 impl RequestType {
@@ -32,6 +34,8 @@ impl RequestType {
             RequestType::PromptsList => "prompts/list",
             RequestType::CompletionComplete => "completion/complete",
             RequestType::Ping => "ping",
+            RequestType::ListTools => "tools/list",
+            RequestType::ListResourceTemplates => "resources/templates/list",
         }
     }
 }
@@ -402,3 +406,17 @@ pub struct Completion {
     pub values: Vec<String>,
     pub total: CompletionTotal,
 }
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CallToolResponse {
+    pub tool_result: serde_json::Value,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ListToolsResponse {
+    pub tools: Vec<Tool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub next_cursor: Option<String>,
+}

crates/copilot/src/copilot_chat.rs

@@ -29,20 +29,42 @@ pub enum Role {
 #[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, EnumIter)]
 pub enum Model {
     #[default]
-    #[serde(alias = "gpt-4o", rename = "gpt-4o-2024-05-13")]
+    #[serde(rename = "gpt-4o")]
     Gpt4o,
-    #[serde(alias = "gpt-4", rename = "gpt-4")]
+    #[serde(rename = "gpt-4o-mini")]
+    Gpt4oMini,
+    #[serde(rename = "gpt-4")]
     Gpt4,
-    #[serde(alias = "gpt-3.5-turbo", rename = "gpt-3.5-turbo")]
+    #[serde(rename = "gpt-4-turbo")]
+    Gpt4Turbo,
+    #[serde(rename = "gpt-3.5-turbo")]
     Gpt3_5Turbo,
+    #[serde(rename = "o1-preview")]
+    O1Preview,
+    #[serde(rename = "o1-mini")]
+    O1Mini,
+    #[serde(rename = "claude-3.5-sonnet")]
+    Claude3_5Sonnet,
 }
 
 impl Model {
+    pub fn uses_streaming(&self) -> bool {
+        match self {
+            Self::O1Mini | Self::O1Preview => false,
+            _ => true,
+        }
+    }
+
     pub fn from_id(id: &str) -> Result<Self> {
         match id {
             "gpt-4o" => Ok(Self::Gpt4o),
+            "gpt-4o-mini" => Ok(Self::Gpt4oMini),
             "gpt-4" => Ok(Self::Gpt4),
+            "gpt-4-turbo" => Ok(Self::Gpt4Turbo),
             "gpt-3.5-turbo" => Ok(Self::Gpt3_5Turbo),
+            "o1-preview" => Ok(Self::O1Preview),
+            "o1-mini" => Ok(Self::O1Mini),
+            "claude-3-5-sonnet" => Ok(Self::Claude3_5Sonnet),
             _ => Err(anyhow!("Invalid model id: {}", id)),
         }
     }
@@ -51,23 +73,37 @@ impl Model {
         match self {
             Self::Gpt3_5Turbo => "gpt-3.5-turbo",
             Self::Gpt4 => "gpt-4",
+            Self::Gpt4Turbo => "gpt-4-turbo",
             Self::Gpt4o => "gpt-4o",
+            Self::Gpt4oMini => "gpt-4o-mini",
+            Self::O1Mini => "o1-mini",
+            Self::O1Preview => "o1-preview",
+            Self::Claude3_5Sonnet => "claude-3-5-sonnet",
         }
     }
-
     pub fn display_name(&self) -> &'static str {
         match self {
             Self::Gpt3_5Turbo => "GPT-3.5",
             Self::Gpt4 => "GPT-4",
+            Self::Gpt4Turbo => "GPT-4 Turbo",
             Self::Gpt4o => "GPT-4o",
+            Self::Gpt4oMini => "GPT-4o Mini",
+            Self::O1Mini => "o1-mini",
+            Self::O1Preview => "o1-preview",
+            Self::Claude3_5Sonnet => "Claude 3.5 Sonnet",
         }
     }
 
     pub fn max_token_count(&self) -> usize {
         match self {
-            Self::Gpt4o => 128000,
-            Self::Gpt4 => 8192,
-            Self::Gpt3_5Turbo => 16385,
+            Self::Gpt4o => 64000,
+            Self::Gpt4oMini => 12288,
+            Self::Gpt4 => 32768,
+            Self::Gpt4Turbo => 64000,
+            Self::Gpt3_5Turbo => 12288,
+            Self::O1Mini => 20000,
+            Self::O1Preview => 20000,
+            Self::Claude3_5Sonnet => 200_000,
         }
     }
 }
@@ -87,7 +123,7 @@ impl Request {
         Self {
             intent: true,
             n: 1,
-            stream: true,
+            stream: model.uses_streaming(),
             temperature: 0.1,
             model,
             messages,
@@ -113,7 +149,8 @@ pub struct ResponseEvent {
 pub struct ResponseChoice {
     pub index: usize,
     pub finish_reason: Option<String>,
-    pub delta: ResponseDelta,
+    pub delta: Option<ResponseDelta>,
+    pub message: Option<ResponseDelta>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -333,9 +370,23 @@ async fn stream_completion(
     if let Some(low_speed_timeout) = low_speed_timeout {
         request_builder = request_builder.read_timeout(low_speed_timeout);
     }
+    let is_streaming = request.stream;
+
     let request = request_builder.body(AsyncBody::from(serde_json::to_string(&request)?))?;
     let mut response = client.send(request).await?;
-    if response.status().is_success() {
+
+    if !response.status().is_success() {
+        let mut body = Vec::new();
+        response.body_mut().read_to_end(&mut body).await?;
+        let body_str = std::str::from_utf8(&body)?;
+        return Err(anyhow!(
+            "Failed to connect to API: {} {}",
+            response.status(),
+            body_str
+        ));
+    }
+
+    if is_streaming {
         let reader = BufReader::new(response.into_body());
         Ok(reader
             .lines()
@@ -367,19 +418,9 @@ async fn stream_completion(
     } else {
         let mut body = Vec::new();
         response.body_mut().read_to_end(&mut body).await?;
-
         let body_str = std::str::from_utf8(&body)?;
+        let response: ResponseEvent = serde_json::from_str(body_str)?;
 
-        match serde_json::from_str::<ResponseEvent>(body_str) {
-            Ok(_) => Err(anyhow!(
-                "Unexpected success response while expecting an error: {}",
-                body_str,
-            )),
-            Err(_) => Err(anyhow!(
-                "Failed to connect to API: {} {}",
-                response.status(),
-                body_str,
-            )),
-        }
+        Ok(futures::stream::once(async move { Ok(response) }).boxed())
     }
 }

crates/copilot/src/sign_in.rs

@@ -185,7 +185,7 @@ impl Render for CopilotCodeVerification {
 
         v_flex()
             .id("copilot code verification")
-            .track_focus(&self.focus_handle)
+            .track_focus(&self.focus_handle(cx))
             .elevation_3(cx)
             .w_96()
             .items_center()

crates/diagnostics/Cargo.toml

@@ -18,7 +18,6 @@ collections.workspace = true
 ctor.workspace = true
 editor.workspace = true
 env_logger.workspace = true
-futures.workspace = true
 gpui.workspace = true
 language.workspace = true
 log.workspace = true

crates/diagnostics/src/diagnostics.rs

@@ -14,10 +14,6 @@ use editor::{
     scroll::Autoscroll,
     Editor, EditorEvent, ExcerptId, ExcerptRange, MultiBuffer, ToOffset,
 };
-use futures::{
-    channel::mpsc::{self, UnboundedSender},
-    StreamExt as _,
-};
 use gpui::{
     actions, div, svg, AnyElement, AnyView, AppContext, Context, EventEmitter, FocusHandle,
     FocusableView, HighlightStyle, InteractiveElement, IntoElement, Model, ParentElement, Render,
@@ -62,11 +58,10 @@ struct ProjectDiagnosticsEditor {
     summary: DiagnosticSummary,
     excerpts: Model<MultiBuffer>,
     path_states: Vec<PathState>,
-    paths_to_update: BTreeSet<(ProjectPath, LanguageServerId)>,
+    paths_to_update: BTreeSet<(ProjectPath, Option<LanguageServerId>)>,
     include_warnings: bool,
     context: u32,
-    update_paths_tx: UnboundedSender<(ProjectPath, Option<LanguageServerId>)>,
-    _update_excerpts_task: Task<Result<()>>,
+    update_excerpts_task: Option<Task<Result<()>>>,
     _subscription: Subscription,
 }
 
@@ -101,7 +96,7 @@ impl Render for ProjectDiagnosticsEditor {
         };
 
         div()
-            .track_focus(&self.focus_handle)
+            .track_focus(&self.focus_handle(cx))
             .when(self.path_states.is_empty(), |el| {
                 el.key_context("EmptyPane")
             })
@@ -129,14 +124,14 @@ impl ProjectDiagnosticsEditor {
                 }
                 project::Event::DiskBasedDiagnosticsFinished { language_server_id } => {
                     log::debug!("disk based diagnostics finished for server {language_server_id}");
-                    this.enqueue_update_stale_excerpts(Some(*language_server_id));
+                    this.update_stale_excerpts(cx);
                 }
                 project::Event::DiagnosticsUpdated {
                     language_server_id,
                     path,
                 } => {
                     this.paths_to_update
-                        .insert((path.clone(), *language_server_id));
+                        .insert((path.clone(), Some(*language_server_id)));
                     this.summary = project.read(cx).diagnostic_summary(false, cx);
                     cx.emit(EditorEvent::TitleChanged);
 
@@ -144,7 +139,7 @@ impl ProjectDiagnosticsEditor {
                         log::debug!("diagnostics updated for server {language_server_id}, path {path:?}. recording change");
                     } else {
                         log::debug!("diagnostics updated for server {language_server_id}, path {path:?}. updating excerpts");
-                        this.enqueue_update_stale_excerpts(Some(*language_server_id));
+                        this.update_stale_excerpts(cx);
                     }
                 }
                 _ => {}
@@ -171,14 +166,12 @@ impl ProjectDiagnosticsEditor {
                         cx.focus(&this.focus_handle);
                     }
                 }
-                EditorEvent::Blurred => this.enqueue_update_stale_excerpts(None),
+                EditorEvent::Blurred => this.update_stale_excerpts(cx),
                 _ => {}
             }
         })
         .detach();
 
-        let (update_excerpts_tx, mut update_excerpts_rx) = mpsc::unbounded();
-
         let project = project_handle.read(cx);
         let mut this = Self {
             project: project_handle.clone(),
@@ -191,27 +184,45 @@ impl ProjectDiagnosticsEditor {
             path_states: Default::default(),
             paths_to_update: Default::default(),
             include_warnings: ProjectDiagnosticsSettings::get_global(cx).include_warnings,
-            update_paths_tx: update_excerpts_tx,
-            _update_excerpts_task: cx.spawn(move |this, mut cx| async move {
-                while let Some((path, language_server_id)) = update_excerpts_rx.next().await {
-                    if let Some(buffer) = project_handle
-                        .update(&mut cx, |project, cx| project.open_buffer(path.clone(), cx))?
-                        .await
-                        .log_err()
-                    {
-                        this.update(&mut cx, |this, cx| {
-                            this.update_excerpts(path, language_server_id, buffer, cx);
-                        })?;
-                    }
-                }
-                anyhow::Ok(())
-            }),
+            update_excerpts_task: None,
             _subscription: project_event_subscription,
         };
-        this.enqueue_update_all_excerpts(cx);
+        this.update_all_excerpts(cx);
         this
     }
 
+    fn update_stale_excerpts(&mut self, cx: &mut ViewContext<Self>) {
+        if self.update_excerpts_task.is_some() {
+            return;
+        }
+        let project_handle = self.project.clone();
+        self.update_excerpts_task = Some(cx.spawn(|this, mut cx| async move {
+            loop {
+                let Some((path, language_server_id)) = this.update(&mut cx, |this, _| {
+                    let Some((path, language_server_id)) = this.paths_to_update.pop_first() else {
+                        this.update_excerpts_task.take();
+                        return None;
+                    };
+                    Some((path, language_server_id))
+                })?
+                else {
+                    break;
+                };
+
+                if let Some(buffer) = project_handle
+                    .update(&mut cx, |project, cx| project.open_buffer(path.clone(), cx))?
+                    .await
+                    .log_err()
+                {
+                    this.update(&mut cx, |this, cx| {
+                        this.update_excerpts(path, language_server_id, buffer, cx);
+                    })?;
+                }
+            }
+            Ok(())
+        }));
+    }
+
     fn new(
         project_handle: Model<Project>,
         workspace: WeakView<Workspace>,
@@ -239,7 +250,7 @@ impl ProjectDiagnosticsEditor {
 
     fn toggle_warnings(&mut self, _: &ToggleWarnings, cx: &mut ViewContext<Self>) {
         self.include_warnings = !self.include_warnings;
-        self.enqueue_update_all_excerpts(cx);
+        self.update_all_excerpts(cx);
         cx.notify();
     }
 
@@ -251,37 +262,28 @@ impl ProjectDiagnosticsEditor {
 
     fn focus_out(&mut self, cx: &mut ViewContext<Self>) {
         if !self.focus_handle.is_focused(cx) && !self.editor.focus_handle(cx).is_focused(cx) {
-            self.enqueue_update_stale_excerpts(None);
+            self.update_stale_excerpts(cx);
         }
     }
 
     /// Enqueue an update of all excerpts. Updates all paths that either
     /// currently have diagnostics or are currently present in this view.
-    fn enqueue_update_all_excerpts(&mut self, cx: &mut ViewContext<Self>) {
+    fn update_all_excerpts(&mut self, cx: &mut ViewContext<Self>) {
         self.project.update(cx, |project, cx| {
             let mut paths = project
                 .diagnostic_summaries(false, cx)
-                .map(|(path, _, _)| path)
+                .map(|(path, _, _)| (path, None))
                 .collect::<BTreeSet<_>>();
-            paths.extend(self.path_states.iter().map(|state| state.path.clone()));
-            for path in paths {
-                self.update_paths_tx.unbounded_send((path, None)).unwrap();
-            }
+            paths.extend(
+                self.path_states
+                    .iter()
+                    .map(|state| (state.path.clone(), None)),
+            );
+            let paths_to_update = std::mem::take(&mut self.paths_to_update);
+            paths.extend(paths_to_update.into_iter().map(|(path, _)| (path, None)));
+            self.paths_to_update = paths;
         });
-    }
-
-    /// Enqueue an update of the excerpts for any path whose diagnostics are known
-    /// to have changed. If a language server id is passed, then only the excerpts for
-    /// that language server's diagnostics will be updated. Otherwise, all stale excerpts
-    /// will be refreshed.
-    fn enqueue_update_stale_excerpts(&mut self, language_server_id: Option<LanguageServerId>) {
-        for (path, server_id) in &self.paths_to_update {
-            if language_server_id.map_or(true, |id| id == *server_id) {
-                self.update_paths_tx
-                    .unbounded_send((path.clone(), Some(*server_id)))
-                    .unwrap();
-            }
-        }
+        self.update_stale_excerpts(cx);
     }
 
     fn update_excerpts(
@@ -291,11 +293,6 @@ impl ProjectDiagnosticsEditor {
         buffer: Model<Buffer>,
         cx: &mut ViewContext<Self>,
     ) {
-        self.paths_to_update.retain(|(path, server_id)| {
-            *path != path_to_update
-                || server_to_update.map_or(false, |to_update| *server_id != to_update)
-        });
-
         let was_empty = self.path_states.is_empty();
         let snapshot = buffer.read(cx).snapshot();
         let path_ix = match self

crates/diagnostics/src/diagnostics_tests.rs

@@ -800,7 +800,7 @@ async fn test_random_diagnostics(cx: &mut TestAppContext, mut rng: StdRng) {
     }
 
     log::info!("updating mutated diagnostics view");
-    mutated_view.update(cx, |view, _| view.enqueue_update_stale_excerpts(None));
+    mutated_view.update(cx, |view, cx| view.update_stale_excerpts(cx));
     cx.run_until_parked();
 
     log::info!("constructing reference diagnostics view");
@@ -986,6 +986,7 @@ fn editor_blocks(
                                     em_width: px(0.),
                                     max_width: px(0.),
                                     block_id,
+                                    selected: false,
                                     editor_style: &editor::EditorStyle::default(),
                                 });
                                 let element = element.downcast_mut::<Stateful<Div>>().unwrap();

crates/diagnostics/src/items.rs

@@ -136,11 +136,12 @@ impl DiagnosticIndicator {
     }
 
     fn update(&mut self, editor: View<Editor>, cx: &mut ViewContext<Self>) {
-        let editor = editor.read(cx);
-        let buffer = editor.buffer().read(cx);
-        let cursor_position = editor.selections.newest::<usize>(cx).head();
+        let (buffer, cursor_position) = editor.update(cx, |editor, cx| {
+            let buffer = editor.buffer().read(cx).snapshot(cx);
+            let cursor_position = editor.selections.newest::<usize>(cx).head();
+            (buffer, cursor_position)
+        });
         let new_diagnostic = buffer
-            .snapshot(cx)
             .diagnostics_in_range::<_, usize>(cursor_position..cursor_position, false)
             .filter(|entry| !entry.range.is_empty())
             .min_by_key(|entry| (entry.diagnostic.severity, entry.range.len()))

crates/diagnostics/src/toolbar_controls.rs

@@ -14,12 +14,12 @@ impl Render for ToolbarControls {
         let mut has_stale_excerpts = false;
         let mut is_updating = false;
 
-        if let Some(editor) = self.editor() {
-            let editor = editor.read(cx);
-            include_warnings = editor.include_warnings;
-            has_stale_excerpts = !editor.paths_to_update.is_empty();
-            is_updating = !editor.update_paths_tx.is_empty()
-                || editor
+        if let Some(editor) = self.diagnostics() {
+            let diagnostics = editor.read(cx);
+            include_warnings = diagnostics.include_warnings;
+            has_stale_excerpts = !diagnostics.paths_to_update.is_empty();
+            is_updating = diagnostics.update_excerpts_task.is_some()
+                || diagnostics
                     .project
                     .read(cx)
                     .language_servers_running_disk_based_diagnostics(cx)
@@ -49,9 +49,9 @@ impl Render for ToolbarControls {
                         .disabled(is_updating)
                         .tooltip(move |cx| Tooltip::text("Update excerpts", cx))
                         .on_click(cx.listener(|this, _, cx| {
-                            if let Some(editor) = this.editor() {
-                                editor.update(cx, |editor, _| {
-                                    editor.enqueue_update_stale_excerpts(None);
+                            if let Some(diagnostics) = this.diagnostics() {
+                                diagnostics.update(cx, |diagnostics, cx| {
+                                    diagnostics.update_all_excerpts(cx);
                                 });
                             }
                         })),
@@ -63,7 +63,7 @@ impl Render for ToolbarControls {
                     .shape(IconButtonShape::Square)
                     .tooltip(move |cx| Tooltip::text(tooltip, cx))
                     .on_click(cx.listener(|this, _, cx| {
-                        if let Some(editor) = this.editor() {
+                        if let Some(editor) = this.diagnostics() {
                             editor.update(cx, |editor, cx| {
                                 editor.toggle_warnings(&Default::default(), cx);
                             });
@@ -105,7 +105,7 @@ impl ToolbarControls {
         ToolbarControls { editor: None }
     }
 
-    fn editor(&self) -> Option<View<ProjectDiagnosticsEditor>> {
+    fn diagnostics(&self) -> Option<View<ProjectDiagnosticsEditor>> {
         self.editor.as_ref()?.upgrade()
     }
 }

crates/editor/Cargo.toml

@@ -76,6 +76,8 @@ theme.workspace = true
 tree-sitter-html = { workspace = true, optional = true }
 tree-sitter-rust = { workspace = true, optional = true }
 tree-sitter-typescript = { workspace = true, optional = true }
+unicode-segmentation.workspace = true
+unicode-script.workspace = true
 unindent = { workspace = true, optional = true }
 ui.workspace = true
 url.workspace = true

crates/editor/src/actions.rs

@@ -80,6 +80,8 @@ pub struct ConfirmCodeAction {
 pub struct ToggleComments {
     #[serde(default)]
     pub advance_downwards: bool,
+    #[serde(default)]
+    pub ignore_indent: bool,
 }
 
 #[derive(PartialEq, Clone, Deserialize, Default)]
@@ -157,6 +159,13 @@ pub struct DeleteToPreviousWordStart {
 pub struct FoldAtLevel {
     pub level: u32,
 }
+
+#[derive(PartialEq, Clone, Deserialize, Default)]
+pub struct SpawnNearestTask {
+    #[serde(default)]
+    pub reveal: task::RevealStrategy,
+}
+
 impl_actions!(
     editor,
     [
@@ -182,6 +191,7 @@ impl_actions!(
         SelectToBeginningOfLine,
         SelectToEndOfLine,
         SelectUpByLines,
+        SpawnNearestTask,
         ShowCompletions,
         ToggleCodeActions,
         ToggleComments,

crates/editor/src/display_map.rs

@@ -21,6 +21,7 @@ mod block_map;
 mod crease_map;
 mod fold_map;
 mod inlay_map;
+pub(crate) mod invisibles;
 mod tab_map;
 mod wrap_map;
 
@@ -35,13 +36,14 @@ use block_map::{BlockRow, BlockSnapshot};
 use collections::{HashMap, HashSet};
 pub use crease_map::*;
 pub use fold_map::{Fold, FoldId, FoldPlaceholder, FoldPoint};
-use fold_map::{FoldMap, FoldSnapshot};
+use fold_map::{FoldMap, FoldMapWriter, FoldOffset, FoldSnapshot};
 use gpui::{
     AnyElement, Font, HighlightStyle, LineLayout, Model, ModelContext, Pixels, UnderlineStyle,
 };
 pub(crate) use inlay_map::Inlay;
 use inlay_map::{InlayMap, InlaySnapshot};
 pub use inlay_map::{InlayOffset, InlayPoint};
+use invisibles::{is_invisible, replacement};
 use language::{
     language_settings::language_settings, ChunkRenderer, OffsetUtf16, Point,
     Subscription as BufferSubscription,
@@ -56,14 +58,16 @@ use std::{
     any::TypeId,
     borrow::Cow,
     fmt::Debug,
+    iter,
     num::NonZeroU32,
     ops::{Add, Range, Sub},
     sync::Arc,
 };
 use sum_tree::{Bias, TreeMap};
 use tab_map::{TabMap, TabSnapshot};
-use text::LineIndent;
-use ui::WindowContext;
+use text::{Edit, LineIndent};
+use ui::{div, px, IntoElement, ParentElement, SharedString, Styled, WindowContext};
+use unicode_segmentation::UnicodeSegmentation;
 use wrap_map::{WrapMap, WrapSnapshot};
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
@@ -202,34 +206,41 @@ impl DisplayMap {
         );
     }
 
+    /// Creates folds for the given ranges.
     pub fn fold<T: ToOffset>(
         &mut self,
         ranges: impl IntoIterator<Item = (Range<T>, FoldPlaceholder)>,
         cx: &mut ModelContext<Self>,
     ) {
-        let snapshot = self.buffer.read(cx).snapshot(cx);
-        let edits = self.buffer_subscription.consume().into_inner();
-        let tab_size = Self::tab_size(&self.buffer, cx);
-        let (snapshot, edits) = self.inlay_map.sync(snapshot, edits);
-        let (mut fold_map, snapshot, edits) = self.fold_map.write(snapshot, edits);
-        let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
-        let (snapshot, edits) = self
-            .wrap_map
-            .update(cx, |map, cx| map.sync(snapshot, edits, cx));
-        self.block_map.read(snapshot, edits);
-        let (snapshot, edits) = fold_map.fold(ranges);
-        let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
-        let (snapshot, edits) = self
-            .wrap_map
-            .update(cx, |map, cx| map.sync(snapshot, edits, cx));
-        self.block_map.read(snapshot, edits);
+        self.update_fold_map(cx, |fold_map| fold_map.fold(ranges))
     }
 
-    pub fn unfold<T: ToOffset>(
+    /// Removes any folds with the given ranges.
+    pub fn remove_folds_with_type<T: ToOffset>(
+        &mut self,
+        ranges: impl IntoIterator<Item = Range<T>>,
+        type_id: TypeId,
+        cx: &mut ModelContext<Self>,
+    ) {
+        self.update_fold_map(cx, |fold_map| fold_map.remove_folds(ranges, type_id))
+    }
+
+    /// Removes any folds whose ranges intersect any of the given ranges.
+    pub fn unfold_intersecting<T: ToOffset>(
         &mut self,
         ranges: impl IntoIterator<Item = Range<T>>,
         inclusive: bool,
         cx: &mut ModelContext<Self>,
+    ) {
+        self.update_fold_map(cx, |fold_map| {
+            fold_map.unfold_intersecting(ranges, inclusive)
+        })
+    }
+
+    fn update_fold_map(
+        &mut self,
+        cx: &mut ModelContext<Self>,
+        callback: impl FnOnce(&mut FoldMapWriter) -> (FoldSnapshot, Vec<Edit<FoldOffset>>),
     ) {
         let snapshot = self.buffer.read(cx).snapshot(cx);
         let edits = self.buffer_subscription.consume().into_inner();
@@ -241,7 +252,7 @@ impl DisplayMap {
             .wrap_map
             .update(cx, |map, cx| map.sync(snapshot, edits, cx));
         self.block_map.read(snapshot, edits);
-        let (snapshot, edits) = fold_map.unfold(ranges, inclusive);
+        let (snapshot, edits) = callback(&mut fold_map);
         let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
         let (snapshot, edits) = self
             .wrap_map
@@ -461,6 +472,98 @@ pub struct HighlightedChunk<'a> {
     pub renderer: Option<ChunkRenderer>,
 }
 
+impl<'a> HighlightedChunk<'a> {
+    fn highlight_invisibles(
+        self,
+        editor_style: &'a EditorStyle,
+    ) -> impl Iterator<Item = Self> + 'a {
+        let mut chars = self.text.chars().peekable();
+        let mut text = self.text;
+        let style = self.style;
+        let is_tab = self.is_tab;
+        let renderer = self.renderer;
+        iter::from_fn(move || {
+            let mut prefix_len = 0;
+            while let Some(&ch) = chars.peek() {
+                if !is_invisible(ch) {
+                    prefix_len += ch.len_utf8();
+                    chars.next();
+                    continue;
+                }
+                if prefix_len > 0 {
+                    let (prefix, suffix) = text.split_at(prefix_len);
+                    text = suffix;
+                    return Some(HighlightedChunk {
+                        text: prefix,
+                        style,
+                        is_tab,
+                        renderer: renderer.clone(),
+                    });
+                }
+                chars.next();
+                let (prefix, suffix) = text.split_at(ch.len_utf8());
+                text = suffix;
+                if let Some(replacement) = replacement(ch) {
+                    let background = editor_style.status.hint_background;
+                    let underline = editor_style.status.hint;
+                    return Some(HighlightedChunk {
+                        text: prefix,
+                        style: None,
+                        is_tab: false,
+                        renderer: Some(ChunkRenderer {
+                            render: Arc::new(move |_| {
+                                div()
+                                    .child(replacement)
+                                    .bg(background)
+                                    .text_decoration_1()
+                                    .text_decoration_color(underline)
+                                    .into_any_element()
+                            }),
+                            constrain_width: false,
+                        }),
+                    });
+                } else {
+                    let invisible_highlight = HighlightStyle {
+                        background_color: Some(editor_style.status.hint_background),
+                        underline: Some(UnderlineStyle {
+                            color: Some(editor_style.status.hint),
+                            thickness: px(1.),
+                            wavy: false,
+                        }),
+                        ..Default::default()
+                    };
+                    let invisible_style = if let Some(mut style) = style {
+                        style.highlight(invisible_highlight);
+                        style
+                    } else {
+                        invisible_highlight
+                    };
+
+                    return Some(HighlightedChunk {
+                        text: prefix,
+                        style: Some(invisible_style),
+                        is_tab: false,
+                        renderer: renderer.clone(),
+                    });
+                }
+            }
+
+            if !text.is_empty() {
+                let remainder = text;
+                text = "";
+                Some(HighlightedChunk {
+                    text: remainder,
+                    style,
+                    is_tab,
+                    renderer: renderer.clone(),
+                })
+            } else {
+                None
+            }
+        })
+    }
+}
+
 #[derive(Clone)]
 pub struct DisplaySnapshot {
     pub buffer_snapshot: MultiBufferSnapshot,
@@ -564,7 +667,7 @@ impl DisplaySnapshot {
         new_start..new_end
     }
 
-    fn point_to_display_point(&self, point: MultiBufferPoint, bias: Bias) -> DisplayPoint {
+    pub fn point_to_display_point(&self, point: MultiBufferPoint, bias: Bias) -> DisplayPoint {
         let inlay_point = self.inlay_snapshot.to_inlay_point(point);
         let fold_point = self.fold_snapshot.to_fold_point(inlay_point, bias);
         let tab_point = self.tab_snapshot.to_tab_point(fold_point);
@@ -573,7 +676,7 @@ impl DisplaySnapshot {
         DisplayPoint(block_point)
     }
 
-    fn display_point_to_point(&self, point: DisplayPoint, bias: Bias) -> Point {
+    pub fn display_point_to_point(&self, point: DisplayPoint, bias: Bias) -> Point {
         self.inlay_snapshot
             .to_buffer_point(self.display_point_to_inlay_point(point, bias))
     }
@@ -595,7 +698,7 @@ impl DisplaySnapshot {
 
     fn display_point_to_inlay_point(&self, point: DisplayPoint, bias: Bias) -> InlayPoint {
         let block_point = point.0;
-        let wrap_point = self.block_snapshot.to_wrap_point(block_point);
+        let wrap_point = self.block_snapshot.to_wrap_point(block_point, bias);
         let tab_point = self.wrap_snapshot.to_tab_point(wrap_point);
         let fold_point = self.tab_snapshot.to_fold_point(tab_point, bias).0;
         fold_point.to_inlay_point(&self.fold_snapshot)
@@ -603,7 +706,7 @@ impl DisplaySnapshot {
 
     pub fn display_point_to_fold_point(&self, point: DisplayPoint, bias: Bias) -> FoldPoint {
         let block_point = point.0;
-        let wrap_point = self.block_snapshot.to_wrap_point(block_point);
+        let wrap_point = self.block_snapshot.to_wrap_point(block_point, bias);
         let tab_point = self.wrap_snapshot.to_tab_point(wrap_point);
         self.tab_snapshot.to_fold_point(tab_point, bias).0
     }
@@ -675,7 +778,7 @@ impl DisplaySnapshot {
                 suggestion: Some(editor_style.suggestions_style),
             },
         )
-        .map(|chunk| {
+        .flat_map(|chunk| {
             let mut highlight_style = chunk
                 .syntax_highlight_id
                 .and_then(|id| id.style(&editor_style.syntax));
@@ -718,6 +821,7 @@ impl DisplaySnapshot {
                 is_tab: chunk.is_tab,
                 renderer: chunk.renderer,
             }
+            .highlight_invisibles(editor_style)
         })
     }
 
@@ -784,12 +888,10 @@ impl DisplaySnapshot {
         layout_line.closest_index_for_x(x) as u32
     }
 
-    pub fn display_chars_at(
-        &self,
-        mut point: DisplayPoint,
-    ) -> impl Iterator<Item = (char, DisplayPoint)> + '_ {
+    pub fn grapheme_at(&self, mut point: DisplayPoint) -> Option<SharedString> {
         point = DisplayPoint(self.block_snapshot.clip_point(point.0, Bias::Left));
-        self.text_chunks(point.row())
+        let chars = self
+            .text_chunks(point.row())
             .flat_map(str::chars)
             .skip_while({
                 let mut column = 0;
@@ -799,16 +901,24 @@ impl DisplaySnapshot {
                     !at_point
                 }
             })
-            .map(move |ch| {
-                let result = (ch, point);
-                if ch == '\n' {
-                    *point.row_mut() += 1;
-                    *point.column_mut() = 0;
-                } else {
-                    *point.column_mut() += ch.len_utf8() as u32;
+            .take_while({
+                let mut prev = false;
+                move |char| {
+                    let now = char.is_ascii();
+                    let end = char.is_ascii() && (char.is_ascii_whitespace() || prev);
+                    prev = now;
+                    !end
                 }
-                result
-            })
+            });
+        chars.collect::<String>().graphemes(true).next().map(|s| {
+            if let Some(invisible) = s.chars().next().filter(|&c| is_invisible(c)) {
+                replacement(invisible).unwrap_or(s).to_owned().into()
+            } else if s == "\n" {
+                " ".into()
+            } else {
+                s.to_owned().into()
+            }
+        })
     }
 
     pub fn buffer_chars_at(&self, mut offset: usize) -> impl Iterator<Item = (char, usize)> + '_ {
@@ -887,7 +997,7 @@ impl DisplaySnapshot {
     pub fn soft_wrap_indent(&self, display_row: DisplayRow) -> Option<u32> {
         let wrap_row = self
             .block_snapshot
-            .to_wrap_point(BlockPoint::new(display_row.0, 0))
+            .to_wrap_point(BlockPoint::new(display_row.0, 0), Bias::Left)
             .row();
         self.wrap_snapshot.soft_wrap_indent(wrap_row)
     }
@@ -1069,7 +1179,7 @@ impl Sub for DisplayPoint {
 #[serde(transparent)]
 pub struct DisplayRow(pub u32);
 
-impl Add for DisplayRow {
+impl Add<DisplayRow> for DisplayRow {
     type Output = Self;
 
     fn add(self, other: Self) -> Self::Output {
@@ -1077,7 +1187,15 @@ impl Add for DisplayRow {
     }
 }
 
-impl Sub for DisplayRow {
+impl Add<u32> for DisplayRow {
+    type Output = Self;
+
+    fn add(self, other: u32) -> Self::Output {
+        DisplayRow(self.0 + other)
+    }
+}
+
+impl Sub<DisplayRow> for DisplayRow {
     type Output = Self;
 
     fn sub(self, other: Self) -> Self::Output {
@@ -1085,6 +1203,14 @@ impl Sub for DisplayRow {
     }
 }
 
+impl Sub<u32> for DisplayRow {
+    type Output = Self;
+
+    fn sub(self, other: u32) -> Self::Output {
+        DisplayRow(self.0 - other)
+    }
+}
+
 impl DisplayPoint {
     pub fn new(row: DisplayRow, column: u32) -> Self {
         Self(BlockPoint(Point::new(row.0, column)))
@@ -1119,7 +1245,7 @@ impl DisplayPoint {
     }
 
     pub fn to_offset(self, map: &DisplaySnapshot, bias: Bias) -> usize {
-        let wrap_point = map.block_snapshot.to_wrap_point(self.0);
+        let wrap_point = map.block_snapshot.to_wrap_point(self.0, bias);
         let tab_point = map.wrap_snapshot.to_tab_point(wrap_point);
         let fold_point = map.tab_snapshot.to_fold_point(tab_point, bias).0;
         let inlay_point = fold_point.to_inlay_point(&map.fold_snapshot);
@@ -1157,16 +1283,21 @@ pub mod tests {
     use super::*;
     use crate::{movement, test::marked_display_snapshot};
     use block_map::BlockPlacement;
-    use gpui::{div, font, observe, px, AppContext, BorrowAppContext, Context, Element, Hsla};
+    use gpui::{
+        div, font, observe, px, AppContext, BorrowAppContext, Context, Element, Hsla, Rgba,
+    };
     use language::{
         language_settings::{AllLanguageSettings, AllLanguageSettingsContent},
-        Buffer, Language, LanguageConfig, LanguageMatcher,
+        Buffer, Diagnostic, DiagnosticEntry, DiagnosticSet, Language, LanguageConfig,
+        LanguageMatcher,
     };
+    use lsp::LanguageServerId;
     use project::Project;
     use rand::{prelude::*, Rng};
     use settings::SettingsStore;
     use smol::stream::StreamExt;
     use std::{env, sync::Arc};
+    use text::PointUtf16;
     use theme::{LoadThemes, SyntaxTheme};
     use unindent::Unindent as _;
     use util::test::{marked_text_ranges, sample_text};
@@ -1318,7 +1449,7 @@ pub mod tests {
                     if rng.gen() && fold_count > 0 {
                         log::info!("unfolding ranges: {:?}", ranges);
                         map.update(cx, |map, cx| {
-                            map.unfold(ranges, true, cx);
+                            map.unfold_intersecting(ranges, true, cx);
                         });
                     } else {
                         log::info!("folding ranges: {:?}", ranges);
@@ -1821,6 +1952,231 @@ pub mod tests {
         );
     }
 
+    #[gpui::test]
+    async fn test_chunks_with_diagnostics_across_blocks(cx: &mut gpui::TestAppContext) {
+        cx.background_executor
+            .set_block_on_ticks(usize::MAX..=usize::MAX);
+
+        let text = r#"
+            struct A {
+                b: usize;
+            }
+            const c: usize = 1;
+        "#
+        .unindent();
+
+        cx.update(|cx| init_test(cx, |_| {}));
+
+        let buffer = cx.new_model(|cx| Buffer::local(text, cx));
+
+        buffer.update(cx, |buffer, cx| {
+            buffer.update_diagnostics(
+                LanguageServerId(0),
+                DiagnosticSet::new(
+                    [DiagnosticEntry {
+                        range: PointUtf16::new(0, 0)..PointUtf16::new(2, 1),
+                        diagnostic: Diagnostic {
+                            severity: DiagnosticSeverity::ERROR,
+                            group_id: 1,
+                            message: "hi".into(),
+                            ..Default::default()
+                        },
+                    }],
+                    buffer,
+                ),
+                cx,
+            )
+        });
+
+        let buffer = cx.new_model(|cx| MultiBuffer::singleton(buffer, cx));
+        let buffer_snapshot = buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx));
+
+        let map = cx.new_model(|cx| {
+            DisplayMap::new(
+                buffer,
+                font("Courier"),
+                px(16.0),
+                None,
+                true,
+                1,
+                1,
+                0,
+                FoldPlaceholder::test(),
+                cx,
+            )
+        });
+
+        let black = gpui::black().to_rgb();
+        let red = gpui::red().to_rgb();
+
+        // Insert a block in the middle of a multi-line diagnostic.
+        map.update(cx, |map, cx| {
+            map.highlight_text(
+                TypeId::of::<usize>(),
+                vec![
+                    buffer_snapshot.anchor_before(Point::new(3, 9))
+                        ..buffer_snapshot.anchor_after(Point::new(3, 14)),
+                    buffer_snapshot.anchor_before(Point::new(3, 17))
+                        ..buffer_snapshot.anchor_after(Point::new(3, 18)),
+                ],
+                red.into(),
+            );
+            map.insert_blocks(
+                [BlockProperties {
+                    placement: BlockPlacement::Below(
+                        buffer_snapshot.anchor_before(Point::new(1, 0)),
+                    ),
+                    height: 1,
+                    style: BlockStyle::Sticky,
+                    render: Box::new(|_| div().into_any()),
+                    priority: 0,
+                }],
+                cx,
+            )
+        });
+
+        let snapshot = map.update(cx, |map, cx| map.snapshot(cx));
+        let mut chunks = Vec::<(String, Option<DiagnosticSeverity>, Rgba)>::new();
+        for chunk in snapshot.chunks(DisplayRow(0)..DisplayRow(5), true, Default::default()) {
+            let color = chunk
+                .highlight_style
+                .and_then(|style| style.color)
+                .map_or(black, |color| color.to_rgb());
+            if let Some((last_chunk, last_severity, last_color)) = chunks.last_mut() {
+                if *last_severity == chunk.diagnostic_severity && *last_color == color {
+                    last_chunk.push_str(chunk.text);
+                    continue;
+                }
+            }
+
+            chunks.push((chunk.text.to_string(), chunk.diagnostic_severity, color));
+        }
+
+        assert_eq!(
+            chunks,
+            [
+                (
+                    "struct A {\n    b: usize;\n".into(),
+                    Some(DiagnosticSeverity::ERROR),
+                    black
+                ),
+                ("\n".into(), None, black),
+                ("}".into(), Some(DiagnosticSeverity::ERROR), black),
+                ("\nconst c: ".into(), None, black),
+                ("usize".into(), None, red),
+                (" = ".into(), None, black),
+                ("1".into(), None, red),
+                (";\n".into(), None, black),
+            ]
+        );
+    }
+
+    #[gpui::test]
+    async fn test_point_translation_with_replace_blocks(cx: &mut gpui::TestAppContext) {
+        cx.background_executor
+            .set_block_on_ticks(usize::MAX..=usize::MAX);
+
+        cx.update(|cx| init_test(cx, |_| {}));
+
+        let buffer = cx.update(|cx| MultiBuffer::build_simple("abcde\nfghij\nklmno\npqrst", cx));
+        let buffer_snapshot = buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx));
+        let map = cx.new_model(|cx| {
+            DisplayMap::new(
+                buffer.clone(),
+                font("Courier"),
+                px(16.0),
+                None,
+                true,
+                1,
+                1,
+                0,
+                FoldPlaceholder::test(),
+                cx,
+            )
+        });
+
+        let snapshot = map.update(cx, |map, cx| {
+            map.insert_blocks(
+                [BlockProperties {
+                    placement: BlockPlacement::Replace(
+                        buffer_snapshot.anchor_before(Point::new(1, 2))
+                            ..buffer_snapshot.anchor_after(Point::new(2, 3)),
+                    ),
+                    height: 4,
+                    style: BlockStyle::Fixed,
+                    render: Box::new(|_| div().into_any()),
+                    priority: 0,
+                }],
+                cx,
+            );
+            map.snapshot(cx)
+        });
+
+        assert_eq!(snapshot.text(), "abcde\n\n\n\n\npqrst");
+
+        let point_to_display_points = [
+            (Point::new(1, 0), DisplayPoint::new(DisplayRow(1), 0)),
+            (Point::new(2, 0), DisplayPoint::new(DisplayRow(1), 0)),
+            (Point::new(3, 0), DisplayPoint::new(DisplayRow(5), 0)),
+        ];
+        for (buffer_point, display_point) in point_to_display_points {
+            assert_eq!(
+                snapshot.point_to_display_point(buffer_point, Bias::Left),
+                display_point,
+                "point_to_display_point({:?}, Bias::Left)",
+                buffer_point
+            );
+            assert_eq!(
+                snapshot.point_to_display_point(buffer_point, Bias::Right),
+                display_point,
+                "point_to_display_point({:?}, Bias::Right)",
+                buffer_point
+            );
+        }
+
+        let display_points_to_points = [
+            (
+                DisplayPoint::new(DisplayRow(1), 0),
+                Point::new(1, 0),
+                Point::new(2, 5),
+            ),
+            (
+                DisplayPoint::new(DisplayRow(2), 0),
+                Point::new(1, 0),
+                Point::new(2, 5),
+            ),
+            (
+                DisplayPoint::new(DisplayRow(3), 0),
+                Point::new(1, 0),
+                Point::new(2, 5),
+            ),
+            (
+                DisplayPoint::new(DisplayRow(4), 0),
+                Point::new(1, 0),
+                Point::new(2, 5),
+            ),
+            (
+                DisplayPoint::new(DisplayRow(5), 0),
+                Point::new(3, 0),
+                Point::new(3, 0),
+            ),
+        ];
+        for (display_point, left_buffer_point, right_buffer_point) in display_points_to_points {
+            assert_eq!(
+                snapshot.display_point_to_point(display_point, Bias::Left),
+                left_buffer_point,
+                "display_point_to_point({:?}, Bias::Left)",
+                display_point
+            );
+            assert_eq!(
+                snapshot.display_point_to_point(display_point, Bias::Right),
+                right_buffer_point,
+                "display_point_to_point({:?}, Bias::Right)",
+                display_point
+            );
+        }
+    }
+
     // todo(linux) fails due to pixel differences in text rendering
     #[cfg(target_os = "macos")]
     #[gpui::test]

crates/editor/src/display_map/block_map.rs

@@ -265,6 +265,7 @@ pub struct BlockContext<'a, 'b> {
     pub em_width: Pixels,
     pub line_height: Pixels,
     pub block_id: BlockId,
+    pub selected: bool,
     pub editor_style: &'b EditorStyle,
 }
 
@@ -1311,7 +1312,6 @@ impl BlockSnapshot {
                 let (output_start_row, input_start_row) = cursor.start();
                 let (output_end_row, input_end_row) = cursor.end(&());
                 let output_start = Point::new(output_start_row.0, 0);
-                let output_end = Point::new(output_end_row.0, 0);
                 let input_start = Point::new(input_start_row.0, 0);
                 let input_end = Point::new(input_end_row.0, 0);
 
@@ -1319,10 +1319,10 @@ impl BlockSnapshot {
                     Some(Block::Custom(block))
                         if matches!(block.placement, BlockPlacement::Replace(_)) =>
                     {
-                        if bias == Bias::Left {
+                        if ((bias == Bias::Left || search_left) && output_start <= point.0)
+                            || (!search_left && output_start >= point.0)
+                        {
                             return BlockPoint(output_start);
-                        } else {
-                            return BlockPoint(Point::new(output_end.row - 1, 0));
                         }
                     }
                     None => {
@@ -1364,12 +1364,7 @@ impl BlockSnapshot {
         cursor.seek(&WrapRow(wrap_point.row()), Bias::Right, &());
         if let Some(transform) = cursor.item() {
             if transform.block.is_some() {
-                let wrap_start = WrapPoint::new(cursor.start().0 .0, 0);
-                if wrap_start == wrap_point {
-                    BlockPoint::new(cursor.start().1 .0, 0)
-                } else {
-                    BlockPoint::new(cursor.end(&()).1 .0 - 1, 0)
-                }
+                BlockPoint::new(cursor.start().1 .0, 0)
             } else {
                 let (input_start_row, output_start_row) = cursor.start();
                 let input_start = Point::new(input_start_row.0, 0);
@@ -1382,7 +1377,7 @@ impl BlockSnapshot {
         }
     }
 
-    pub fn to_wrap_point(&self, block_point: BlockPoint) -> WrapPoint {
+    pub fn to_wrap_point(&self, block_point: BlockPoint, bias: Bias) -> WrapPoint {
         let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>(&());
         cursor.seek(&BlockRow(block_point.row), Bias::Right, &());
         if let Some(transform) = cursor.item() {
@@ -1391,7 +1386,9 @@ impl BlockSnapshot {
                     if block.place_below() {
                         let wrap_row = cursor.start().1 .0 - 1;
                         WrapPoint::new(wrap_row, self.wrap_snapshot.line_len(wrap_row))
-                    } else if block.place_above() || block_point.row == cursor.start().0 .0 {
+                    } else if block.place_above() {
+                        WrapPoint::new(cursor.start().1 .0, 0)
+                    } else if bias == Bias::Left {
                         WrapPoint::new(cursor.start().1 .0, 0)
                     } else {
                         let wrap_row = cursor.end(&()).1 .0 - 1;
@@ -1766,19 +1763,19 @@ mod tests {
         );
 
         assert_eq!(
-            snapshot.to_wrap_point(BlockPoint::new(0, 3)),
+            snapshot.to_wrap_point(BlockPoint::new(0, 3), Bias::Left),
             WrapPoint::new(0, 3)
         );
         assert_eq!(
-            snapshot.to_wrap_point(BlockPoint::new(1, 0)),
+            snapshot.to_wrap_point(BlockPoint::new(1, 0), Bias::Left),
             WrapPoint::new(1, 0)
         );
         assert_eq!(
-            snapshot.to_wrap_point(BlockPoint::new(3, 0)),
+            snapshot.to_wrap_point(BlockPoint::new(3, 0), Bias::Left),
             WrapPoint::new(1, 0)
         );
         assert_eq!(
-            snapshot.to_wrap_point(BlockPoint::new(7, 0)),
+            snapshot.to_wrap_point(BlockPoint::new(7, 0), Bias::Left),
             WrapPoint::new(3, 3)
         );
 
@@ -2616,10 +2613,15 @@ mod tests {
 
             // Ensure that conversion between block points and wrap points is stable.
             for row in 0..=blocks_snapshot.wrap_snapshot.max_point().row() {
-                let original_wrap_point = WrapPoint::new(row, 0);
-                let block_point = blocks_snapshot.to_block_point(original_wrap_point);
-                let wrap_point = blocks_snapshot.to_wrap_point(block_point);
-                assert_eq!(blocks_snapshot.to_block_point(wrap_point), block_point);
+                let wrap_point = WrapPoint::new(row, 0);
+                let block_point = blocks_snapshot.to_block_point(wrap_point);
+                let left_wrap_point = blocks_snapshot.to_wrap_point(block_point, Bias::Left);
+                let right_wrap_point = blocks_snapshot.to_wrap_point(block_point, Bias::Right);
+                assert_eq!(blocks_snapshot.to_block_point(left_wrap_point), block_point);
+                assert_eq!(
+                    blocks_snapshot.to_block_point(right_wrap_point),
+                    block_point
+                );
             }
 
             let mut block_point = BlockPoint::new(0, 0);
@@ -2627,10 +2629,12 @@ mod tests {
                 let left_point = blocks_snapshot.clip_point(block_point, Bias::Left);
                 let left_buffer_point = blocks_snapshot.to_point(left_point, Bias::Left);
                 assert_eq!(
-                    blocks_snapshot.to_block_point(blocks_snapshot.to_wrap_point(left_point)),
+                    blocks_snapshot
+                        .to_block_point(blocks_snapshot.to_wrap_point(left_point, Bias::Left)),
                     left_point,
-                    "wrap point: {:?}",
-                    blocks_snapshot.to_wrap_point(left_point)
+                    "block point: {:?}, wrap point: {:?}",
+                    block_point,
+                    blocks_snapshot.to_wrap_point(left_point, Bias::Left)
                 );
                 assert_eq!(
                     left_buffer_point,
@@ -2642,10 +2646,12 @@ mod tests {
                 let right_point = blocks_snapshot.clip_point(block_point, Bias::Right);
                 let right_buffer_point = blocks_snapshot.to_point(right_point, Bias::Right);
                 assert_eq!(
-                    blocks_snapshot.to_block_point(blocks_snapshot.to_wrap_point(right_point)),
+                    blocks_snapshot
+                        .to_block_point(blocks_snapshot.to_wrap_point(right_point, Bias::Right)),
                     right_point,
-                    "wrap point: {:?}",
-                    blocks_snapshot.to_wrap_point(right_point)
+                    "block point: {:?}, wrap point: {:?}",
+                    block_point,
+                    blocks_snapshot.to_wrap_point(right_point, Bias::Right)
                 );
                 assert_eq!(
                     right_buffer_point,
@@ -2681,7 +2687,8 @@ mod tests {
 
     impl BlockSnapshot {
         fn to_point(&self, point: BlockPoint, bias: Bias) -> Point {
-            self.wrap_snapshot.to_point(self.to_wrap_point(point), bias)
+            self.wrap_snapshot
+                .to_point(self.to_wrap_point(point, bias), bias)
         }
     }
 }

crates/editor/src/display_map/fold_map.rs

@@ -6,12 +6,14 @@ use gpui::{AnyElement, ElementId, WindowContext};
 use language::{Chunk, ChunkRenderer, Edit, Point, TextSummary};
 use multi_buffer::{Anchor, AnchorRangeExt, MultiBufferRow, MultiBufferSnapshot, ToOffset};
 use std::{
+    any::TypeId,
     cmp::{self, Ordering},
     fmt, iter,
     ops::{Add, AddAssign, Deref, DerefMut, Range, Sub},
     sync::Arc,
 };
 use sum_tree::{Bias, Cursor, FilterCursor, SumTree, Summary};
+use ui::IntoElement as _;
 use util::post_inc;
 
 #[derive(Clone)]
@@ -22,17 +24,29 @@ pub struct FoldPlaceholder {
     pub constrain_width: bool,
     /// If true, merges the fold with an adjacent one.
     pub merge_adjacent: bool,
+    /// Category of the fold. Useful for carefully removing from overlapping folds.
+    pub type_tag: Option<TypeId>,
+}
+
+impl Default for FoldPlaceholder {
+    fn default() -> Self {
+        Self {
+            render: Arc::new(|_, _, _| gpui::Empty.into_any_element()),
+            constrain_width: true,
+            merge_adjacent: true,
+            type_tag: None,
+        }
+    }
 }
 
 impl FoldPlaceholder {
     #[cfg(any(test, feature = "test-support"))]
     pub fn test() -> Self {
-        use gpui::IntoElement;
-
         Self {
             render: Arc::new(|_id, _range, _cx| gpui::Empty.into_any_element()),
             constrain_width: true,
             merge_adjacent: true,
+            type_tag: None,
         }
     }
 }
@@ -173,9 +187,34 @@ impl<'a> FoldMapWriter<'a> {
         (self.0.snapshot.clone(), edits)
     }
 
-    pub(crate) fn unfold<T: ToOffset>(
+    /// Removes any folds with the given ranges.
+    pub(crate) fn remove_folds<T: ToOffset>(
         &mut self,
         ranges: impl IntoIterator<Item = Range<T>>,
+        type_id: TypeId,
+    ) -> (FoldSnapshot, Vec<FoldEdit>) {
+        self.remove_folds_with(
+            ranges,
+            |fold| fold.placeholder.type_tag == Some(type_id),
+            false,
+        )
+    }
+
+    /// Removes any folds whose ranges intersect the given ranges.
+    pub(crate) fn unfold_intersecting<T: ToOffset>(
+        &mut self,
+        ranges: impl IntoIterator<Item = Range<T>>,
+        inclusive: bool,
+    ) -> (FoldSnapshot, Vec<FoldEdit>) {
+        self.remove_folds_with(ranges, |_| true, inclusive)
+    }
+
+    /// Removes any folds that intersect the given ranges and for which the given predicate
+    /// returns true.
+    fn remove_folds_with<T: ToOffset>(
+        &mut self,
+        ranges: impl IntoIterator<Item = Range<T>>,
+        should_unfold: impl Fn(&Fold) -> bool,
         inclusive: bool,
     ) -> (FoldSnapshot, Vec<FoldEdit>) {
         let mut edits = Vec::new();
@@ -183,21 +222,23 @@ impl<'a> FoldMapWriter<'a> {
         let snapshot = self.0.snapshot.inlay_snapshot.clone();
         let buffer = &snapshot.buffer;
         for range in ranges.into_iter() {
-            // Remove intersecting folds and add their ranges to edits that are passed to sync.
+            let range = range.start.to_offset(buffer)..range.end.to_offset(buffer);
             let mut folds_cursor =
-                intersecting_folds(&snapshot, &self.0.snapshot.folds, range, inclusive);
+                intersecting_folds(&snapshot, &self.0.snapshot.folds, range.clone(), inclusive);
             while let Some(fold) = folds_cursor.item() {
                 let offset_range =
                     fold.range.start.to_offset(buffer)..fold.range.end.to_offset(buffer);
-                if offset_range.end > offset_range.start {
-                    let inlay_range = snapshot.to_inlay_offset(offset_range.start)
-                        ..snapshot.to_inlay_offset(offset_range.end);
-                    edits.push(InlayEdit {
-                        old: inlay_range.clone(),
-                        new: inlay_range,
-                    });
+                if should_unfold(fold) {
+                    if offset_range.end > offset_range.start {
+                        let inlay_range = snapshot.to_inlay_offset(offset_range.start)
+                            ..snapshot.to_inlay_offset(offset_range.end);
+                        edits.push(InlayEdit {
+                            old: inlay_range.clone(),
+                            new: inlay_range,
+                        });
+                    }
+                    fold_ixs_to_delete.push(*folds_cursor.start());
                 }
-                fold_ixs_to_delete.push(*folds_cursor.start());
                 folds_cursor.next(buffer);
             }
         }
@@ -665,6 +706,8 @@ impl FoldSnapshot {
     where
         T: ToOffset,
     {
+        let buffer = &self.inlay_snapshot.buffer;
+        let range = range.start.to_offset(buffer)..range.end.to_offset(buffer);
         let mut folds = intersecting_folds(&self.inlay_snapshot, &self.folds, range, false);
         iter::from_fn(move || {
             let item = folds.item();
@@ -821,15 +864,12 @@ fn push_isomorphic(transforms: &mut SumTree<Transform>, summary: TextSummary) {
     }
 }
 
-fn intersecting_folds<'a, T>(
+fn intersecting_folds<'a>(
     inlay_snapshot: &'a InlaySnapshot,
     folds: &'a SumTree<Fold>,
-    range: Range<T>,
+    range: Range<usize>,
     inclusive: bool,
-) -> FilterCursor<'a, impl 'a + FnMut(&FoldSummary) -> bool, Fold, usize>
-where
-    T: ToOffset,
-{
+) -> FilterCursor<'a, impl 'a + FnMut(&FoldSummary) -> bool, Fold, usize> {
     let buffer = &inlay_snapshot.buffer;
     let start = buffer.anchor_before(range.start.to_offset(buffer));
     let end = buffer.anchor_after(range.end.to_offset(buffer));
@@ -1419,12 +1459,12 @@ mod tests {
         assert_eq!(snapshot4.text(), "123a⋯c123456eee");
 
         let (mut writer, _, _) = map.write(inlay_snapshot.clone(), vec![]);
-        writer.unfold(Some(Point::new(0, 4)..Point::new(0, 4)), false);
+        writer.unfold_intersecting(Some(Point::new(0, 4)..Point::new(0, 4)), false);
         let (snapshot5, _) = map.read(inlay_snapshot.clone(), vec![]);
         assert_eq!(snapshot5.text(), "123a⋯c123456eee");
 
         let (mut writer, _, _) = map.write(inlay_snapshot.clone(), vec![]);
-        writer.unfold(Some(Point::new(0, 4)..Point::new(0, 4)), true);
+        writer.unfold_intersecting(Some(Point::new(0, 4)..Point::new(0, 4)), true);
         let (snapshot6, _) = map.read(inlay_snapshot, vec![]);
         assert_eq!(snapshot6.text(), "123aaaaa\nbbbbbb\nccc123456eee");
     }
@@ -1913,7 +1953,7 @@ mod tests {
                     log::info!("unfolding {:?} (inclusive: {})", to_unfold, inclusive);
                     let (mut writer, snapshot, edits) = self.write(inlay_snapshot, vec![]);
                     snapshot_edits.push((snapshot, edits));
-                    let (snapshot, edits) = writer.unfold(to_unfold, inclusive);
+                    let (snapshot, edits) = writer.unfold_intersecting(to_unfold, inclusive);
                     snapshot_edits.push((snapshot, edits));
                 }
                 _ => {

crates/editor/src/display_map/inlay_map.rs

@@ -255,6 +255,22 @@ impl<'a> InlayChunks<'a> {
         self.buffer_chunk = None;
         self.output_offset = new_range.start;
         self.max_output_offset = new_range.end;
+
+        let mut highlight_endpoints = Vec::new();
+        if let Some(text_highlights) = self.highlights.text_highlights {
+            if !text_highlights.is_empty() {
+                self.snapshot.apply_text_highlights(
+                    &mut self.transforms,
+                    &new_range,
+                    text_highlights,
+                    &mut highlight_endpoints,
+                );
+                self.transforms.seek(&new_range.start, Bias::Right, &());
+                highlight_endpoints.sort();
+            }
+        }
+        self.highlight_endpoints = highlight_endpoints.into_iter().peekable();
+        self.active_highlights.clear();
     }
 
     pub fn offset(&self) -> InlayOffset {

crates/editor/src/display_map/invisibles.rs

@@ -0,0 +1,129 @@
+// Invisibility in a Unicode context is not well defined, so we have to guess.
+//
+// We highlight all ASCII control codes, and unicode whitespace because they are likely
+// confused with an ASCII space in a programming context (U+0020).
+//
+// We also highlight the handful of blank non-space characters:
+//   U+2800 BRAILLE PATTERN BLANK - Category: So
+//   U+115F HANGUL CHOSEONG FILLER - Category: Lo
+//   U+1160 HANGUL CHOSEONG FILLER - Category: Lo
+//   U+3164 HANGUL FILLER - Category: Lo
+//   U+FFA0 HALFWIDTH HANGUL FILLER - Category: Lo
+//   U+FFFC OBJECT REPLACEMENT CHARACTER - Category: So
+//
+// For the rest of Unicode, invisibility happens for two reasons:
+// * A Format character (like a byte order mark or right-to-left override)
+// * An invisible Nonspacing Mark character (like U+034F, or variation selectors)
+//
+// We don't consider unassigned codepoints invisible as the font renderer already shows
+// a replacement character in that case (and there are a *lot* of them)
+//
+// Control characters are mostly fine to highlight; except:
+// * U+E0020..=U+E007F are used in emoji flags. We don't highlight them right now, but we could if we tightened our heuristics.
+// * U+200D is used to join characters. We highlight this but don't replace it. As our font system ignores mid-glyph highlights this mostly works to highlight unexpected uses.
+//
+// Nonspacing marks are handled like U+200D. This means that mid-glyph we ignore them, but
+// probably causes issues with end-of-glyph usage.
+//
+// ref: https://invisible-characters.com
+// ref: https://www.compart.com/en/unicode/category/Cf
+// ref: https://gist.github.com/ConradIrwin/f759e1fc29267143c4c7895aa495dca5?h=1
+// ref: https://unicode.org/Public/emoji/13.0/emoji-test.txt
+// https://github.com/bits/UTF-8-Unicode-Test-Documents/blob/master/UTF-8_sequence_separated/utf8_sequence_0-0x10ffff_assigned_including-unprintable-asis.txt
+pub fn is_invisible(c: char) -> bool {
+    if c <= '\u{1f}' {
+        c != '\t' && c != '\n' && c != '\r'
+    } else if c >= '\u{7f}' {
+        c <= '\u{9f}'
+            || (c.is_whitespace() && c != IDEOGRAPHIC_SPACE)
+            || contains(c, &FORMAT)
+            || contains(c, &OTHER)
+    } else {
+        false
+    }
+}
+// ASCII control characters have fancy unicode glyphs, everything else
+// is replaced by a space - unless it is used in combining characters in
+// which case we need to leave it in the string.
+pub(crate) fn replacement(c: char) -> Option<&'static str> {
+    if c <= '\x1f' {
+        Some(C0_SYMBOLS[c as usize])
+    } else if c == '\x7f' {
+        Some(DEL)
+    } else if contains(c, &PRESERVE) {
+        None
+    } else {
+        Some("\u{2007}") // fixed width space
+    }
+}
+// IDEOGRAPHIC SPACE is common alongside Chinese and other wide character sets.
+// We don't highlight this for now (as it already shows up wide in the editor),
+// but could if we tracked state in the classifier.
+const IDEOGRAPHIC_SPACE: char = '\u{3000}';
+
+const C0_SYMBOLS: &'static [&'static str] = &[
+    "␀", "␁", "␂", "␃", "␄", "␅", "␆", "␇", "␈", "␉", "␊", "␋", "␌", "␍", "␎", "␏", "␐", "␑", "␒",
+    "␓", "␔", "␕", "␖", "␗", "␘", "␙", "␚", "␛", "␜", "␝", "␞", "␟",
+];
+const DEL: &'static str = "␡";
+
+// generated using ucd-generate: ucd-generate general-category --include Format --chars ucd-16.0.0
+pub const FORMAT: &'static [(char, char)] = &[
+    ('\u{ad}', '\u{ad}'),
+    ('\u{600}', '\u{605}'),
+    ('\u{61c}', '\u{61c}'),
+    ('\u{6dd}', '\u{6dd}'),
+    ('\u{70f}', '\u{70f}'),
+    ('\u{890}', '\u{891}'),
+    ('\u{8e2}', '\u{8e2}'),
+    ('\u{180e}', '\u{180e}'),
+    ('\u{200b}', '\u{200f}'),
+    ('\u{202a}', '\u{202e}'),
+    ('\u{2060}', '\u{2064}'),
+    ('\u{2066}', '\u{206f}'),
+    ('\u{feff}', '\u{feff}'),
+    ('\u{fff9}', '\u{fffb}'),
+    ('\u{110bd}', '\u{110bd}'),
+    ('\u{110cd}', '\u{110cd}'),
+    ('\u{13430}', '\u{1343f}'),
+    ('\u{1bca0}', '\u{1bca3}'),
+    ('\u{1d173}', '\u{1d17a}'),
+    ('\u{e0001}', '\u{e0001}'),
+    ('\u{e0020}', '\u{e007f}'),
+];
+
+// hand-made base on https://invisible-characters.com (Excluding Cf)
+pub const OTHER: &'static [(char, char)] = &[
+    ('\u{034f}', '\u{034f}'),
+    ('\u{115F}', '\u{1160}'),
+    ('\u{17b4}', '\u{17b5}'),
+    ('\u{180b}', '\u{180d}'),
+    ('\u{2800}', '\u{2800}'),
+    ('\u{3164}', '\u{3164}'),
+    ('\u{fe00}', '\u{fe0d}'),
+    ('\u{ffa0}', '\u{ffa0}'),
+    ('\u{fffc}', '\u{fffc}'),
+    ('\u{e0100}', '\u{e01ef}'),
+];
+
+// a subset of FORMAT/OTHER that may appear within glyphs
+const PRESERVE: &'static [(char, char)] = &[
+    ('\u{034f}', '\u{034f}'),
+    ('\u{200d}', '\u{200d}'),
+    ('\u{17b4}', '\u{17b5}'),
+    ('\u{180b}', '\u{180d}'),
+    ('\u{e0061}', '\u{e007a}'),
+    ('\u{e007f}', '\u{e007f}'),
+];
+
+fn contains(c: char, list: &[(char, char)]) -> bool {
+    for (start, end) in list {
+        if c < *start {
+            return false;
+        }
+        if c <= *end {
+            return true;
+        }
+    }
+    false
+}