remove shell command

Release Notes:

- N/A

.clinerules

@@ -1 +0,0 @@
-.rules

.config/hakari.toml

@@ -20,6 +20,7 @@ platforms = [
 [traversal-excludes]
 workspace-members = [
     "remote_server",
+    "eval",
 ]
 third-party = [
     { name = "reqwest", version = "0.11.27" },

.cursorrules

@@ -1 +0,0 @@
-.rules

.github/actions/run_tests/action.yml

@@ -10,7 +10,7 @@ runs:
         cargo install cargo-nextest --locked
 
     - name: Install Node
-      uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+      uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4
       with:
         node-version: "18"
 

.github/actions/run_tests_windows/action.yml

@@ -16,7 +16,7 @@ runs:
       run: cargo install cargo-nextest --locked
 
     - name: Install Node
-      uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+      uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4
       with:
         node-version: "18"
 

.github/workflows/ci.yml

@@ -325,7 +325,7 @@ jobs:
           cache-provider: "buildjet"
 
       - name: Install Clang & Mold
-        run: ./script/remote-server && ./script/install-mold 2.34.0
+        run: ./script/headless && ./script/install-mold 2.34.0
 
       - name: Configure CI
         run: |
@@ -519,7 +519,7 @@ jobs:
       DIGITALOCEAN_SPACES_SECRET_KEY: ${{ secrets.DIGITALOCEAN_SPACES_SECRET_KEY }}
     steps:
       - name: Install Node
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+        uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4
         with:
           node-version: "18"
 

.github/workflows/danger.yml

@@ -22,7 +22,7 @@ jobs:
           version: 9
 
       - name: Setup Node
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+        uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4
         with:
           node-version: "20"
           cache: "pnpm"

.github/workflows/issue_response.yml

@@ -18,7 +18,7 @@ jobs:
           version: 9
 
       - name: Setup Node
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+        uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4
         with:
           node-version: "20"
           cache: "pnpm"

.github/workflows/randomized_tests.yml

@@ -23,7 +23,7 @@ jobs:
       - buildjet-16vcpu-ubuntu-2204
     steps:
       - name: Install Node
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+        uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4
         with:
           node-version: "18"
 

.github/workflows/release_nightly.yml

@@ -71,7 +71,7 @@ jobs:
       ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON: ${{ secrets.ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON }}
     steps:
       - name: Install Node
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+        uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4
         with:
           node-version: "18"
 

.github/workflows/run_agent_eval_daily.yml

@@ -11,8 +11,8 @@ env:
   RUST_BACKTRACE: 1
 
 jobs:
-  run_eval:
-    name: Run Eval
+  build_binary:
+    name: Build Eval Binary
     if: github.repository_owner == 'zed-industries'
     runs-on: ubuntu-latest
     steps:
@@ -21,8 +21,70 @@ jobs:
         with:
           clean: false
 
+      - name: Install Dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libx11-dev libxcb-shape0-dev libxcb-xfixes0-dev libxcb1-dev libxcb-render0-dev libxcb-randr0-dev libxcb-xtest0-dev libxcb-keysyms1-dev libxext-dev libxrender-dev libxrandr-dev libxtst-dev libxfixes-dev pkg-config libasound2-dev libx11-xcb-dev libxkbcommon-dev libxkbcommon-x11-dev
+          ./script/headless && ./script/install-mold 2.34.0
+
       - name: Setup Rust
         uses: dtolnay/rust-toolchain@stable
 
-      - name: Run cargo eval
-        run: cargo run -p eval
+      - name: Build entire Zed application
+        run: cargo build --release
+
+      - name: Build eval binary separately to ensure it's available
+        run: cargo build --release -p eval
+
+      - name: Upload eval binary
+        uses: actions/upload-artifact@v4
+        with:
+          name: eval-binary
+          path: target/release/eval
+
+  run_eval:
+    name: Run Eval - ${{ matrix.exercise }}
+    needs: build_binary
+    if: github.repository_owner == 'zed-industries'
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        exercise:
+          - find_and_replace_diff_card
+          - metal_i64_support
+
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        with:
+          clean: false
+
+      - name: Install Dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libx11-dev libxcb-shape0-dev libxcb-xfixes0-dev libxcb1-dev libxcb-render0-dev libxcb-randr0-dev libxcb-xtest0-dev libxcb-keysyms1-dev libxext-dev libxrender-dev libxrandr-dev libxtst-dev libxfixes-dev pkg-config libasound2-dev libx11-xcb-dev libxkbcommon-dev libxkbcommon-x11-dev
+          ./script/headless && ./script/install-mold 2.34.0
+
+      - name: Create required directories
+        run: |
+          mkdir -p /home/runner/.config/zed
+          touch /home/runner/.config/zed/settings.json
+          mkdir -p ./crates/eval/repos
+          mkdir -p ./crates/eval/worktrees
+          mkdir -p ./crates/eval/runs
+
+      - name: Set up Anthropic API key
+        run: echo "ANTHROPIC_API_KEY=${{ secrets.ANTHROPIC_API_KEY }}" >> $GITHUB_ENV
+
+      - name: Download eval binary
+        uses: actions/download-artifact@v4
+        with:
+          name: eval-binary
+          path: ./target/release/
+
+      - name: Make eval binary executable
+        run: chmod +x ./target/release/eval
+
+      - name: Run eval for ${{ matrix.exercise }}
+        run: ./target/release/eval --cohort-id dailyrun${{ github.run_id }} ${{ matrix.exercise }}

.gitignore

@@ -18,6 +18,7 @@
 .venv
 .vscode
 .wrangler
+/.direnv
 /assets/*licenses.*
 /crates/collab/seed.json
 /crates/theme/schemas/theme.json

.rules

@@ -1,110 +0,0 @@
-# Rust coding guidelines
-
-* Prioritize code correctness and clarity. Speed and efficiency are secondary priorities unless otherwise specified.
-* Do not write organizational or comments that summarize the code. Comments should only be written in order to explain "why" the code is written in some way in the case there is a reason that is tricky / non-obvious.
-* Prefer implementing functionality in existing files unless it is a new logical component. Avoid creating many small files.
-* Avoid using functions that panic like `unwrap()`, instead use mechanisms like `?` to propagate errors.
-* Be careful with operations like indexing which may panic if the indexes are out of bounds.
-
-# GPUI
-
-GPUI is a UI framework which also provides primitives for state and concurrency management.
-
-## Context
-
-Context types allow interaction with global state, windows, entities, and system services. They are typically passed to functions as the argument named `cx`. When a function takes callbacks they come after the `cx` parameter.
-
-* `App` is the root context type, providing access to global state and read and update of entities.
-* `Context<T>` is provided when updating an `Entity<T>`. This context dereferences into `App`, so functions which take `&App` can also take `&Context<T>`.
-* `AsyncApp` and `AsyncWindowContext` are provided by `cx.spawn` and `cx.spawn_in`. These can be held across await points.
-
-## `Window`
-
-`Window` provides access to the state of an application window. It is passed to functions as an argument named `window` and comes before `cx` when present. It is used for managing focus, dispatching actions, directly drawing, getting user input state, etc.
-
-## Entities
-
-An `Entity<T>` is a handle to state of type `T`. With `thing: Entity<T>`:
-
-* `thing.entity_id()` returns `EntityId`
-* `thing.downgrade()` returns `WeakEntity<T>`
-* `thing.read(cx: &App)` returns `&T`.
-* `thing.read_with(cx, |thing: &T, cx: &App| ...)` returns the closure's return value.
-* `thing.update(cx, |thing: &mut T, cx: &mut Context<T>| ...)` allows the closure to mutate the state, and provides a `Context<T>` for interacting with the entity. It returns the closure's return value.
-* `thing.update_in(cx, |thing: &mut T, window: &mut Window, cx: &mut Context<T>| ...)` takes a `AsyncWindowContext` or `VisualTestContext`. It's the same as `update` while also providing the `Window`.
-
-Within the closures, the inner `cx` provided to the closure must be used instead of the outer `cx` to avoid issues with multiple borrows.
-
-Trying to update an entity while it's already being updated must be avoided as this will cause a panic.
-
-When  `read_with`, `update`, or `update_in` are used with an async context, the closure's return value is wrapped in an `anyhow::Result`.
-
-`WeakEntity<T>` is a weak handle. It has `read_with`, `update`, and `update_in` methods that work the same, but always return an `anyhow::Result` so that they can fail if the entity no longer exists. This can be useful to avoid memory leaks - if entities have mutually recursive handles to eachother they will never be dropped.
-
-## Concurrency
-
-All use of entities and UI rendering occurs on a single foreground thread.
-
-`cx.spawn(async move |cx| ...)` runs an async closure on the foreground thread. Within the closure, `cx` is an async context like `AsyncApp` or `AsyncWindowContext`.
-
-When the outer cx is a `Context<T>`, the use of `spawn` instead looks like `cx.spawn(async move |handle, cx| ...)`, where `handle: WeakEntity<T>`.
-
-To do work on other threads, `cx.background_spawn(async move { ... })` is used. Often this background task is awaited on by a foreground task which uses the results to update state.
-
-Both `cx.spawn` and `cx.background_spawn` return a `Task<R>`, which is a future that can be awaited upon. If this task is dropped, then its work is cancelled. To prevent this one of the following must be done:
-
-* Awaiting the task in some other async context.
-* Detaching the task via `task.detach()` or `task.detach_and_log_err(cx)`, allowing it to run indefinitely.
-* Storing the task in a field, if the work should be halted when the struct is dropped.
-
-A task which doesn't do anything but provide a value can be created with `Task::ready(value)`.
-
-## Elements
-
-The `Render` trait is used to render some state into an element tree that is laid out using flexbox layout. An `Entity<T>` where `T` implements `Render` is sometimes called a "view".
-
-Example:
-
-```
-struct TextWithBorder(SharedString);
-
-impl Render for TextWithBorder {
-    fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
-        div().border_1().child(self.0.clone())
-    }
-}
-```
-
-Since `impl IntoElement for SharedString` exists, it can be used as an argument to `child`. `SharedString` is used to avoid copying strings, and is either an `&'static str` or `Arc<str>`.
-
-UI components that are constructed just to be turned into elements can instead implement the `RenderOnce` trait, which is similar to `Render`, but its `render` method takes ownership of `self`. Types that implement this trait can use `#[derive(IntoElement)]` to use them directly as children.
-
-The style methods on elements are similar to those used by Tailwind CSS.
-
-If some attributes or children of an element tree are conditional, `.when(condition, |this| ...)` can be used to run the closure only when `condition` is true. Similarly, `.when_some(option, |this, value| ...)` runs the closure when the `Option` has a value.
-
-## Input events
-
-Input event handlers can be registered on an element via methods like `.on_click(|event, window, cx: &mut App| ...)`.
-
-Often event handlers will want to update the entity that's in the current `Context<T>`. The `cx.listener` method provides this - its use looks like `.on_click(cx.listener(|this: &mut T, event, window, cx: &mut Context<T>| ...)`.
-
-## Actions
-
-Actions are dispatched via user keyboard interaction or in code via `window.dispatch_action(SomeAction.boxed_clone(), cx)` or `focus_handle.dispatch_action(&SomeAction, window, cx)`.
-
-Actions which have no data inside are created and registered with the `actions!(some_namespace, [SomeAction, AnotherAction])` macro call.
-
-Actions that do have data must implement `Clone, Default, PartialEq, Deserialize, JsonSchema` and can be registered with an `impl_actions!(some_namespace, [SomeActionWithData])` macro call.
-
-Action handlers can be registered on an element via the event handler `.on_action(|action, window, cx| ...)`. Like other event handlers, this is often used with `cx.listener`.
-
-## Notify
-
-When a view's state has changed in a way that may affect its rendering, it should call `cx.notify()`. This will cause the view to be rerendered. It will also cause any observe callbacks registered for the entity with `cx.observe` to be called.
-
-## Entity events
-
-While updating an entity (`cx: Context<T>`), it can emit an event using `cx.emit(event)`. Entities register which events they can emit by declaring `impl EventEmittor<EventType> for EntityType {}`.
-
-Other entities can then register a callback to handle these events by doing `cx.subscribe(other_entity, |this, other_entity, event, cx| ...)`. This will return a `Subscription` which deregisters the callback when dropped.  Typically `cx.subscribe` happens when creating a new entity and the subscriptions are stored in a `_subscriptions: Vec<Subscription>` field.

.windsurfrules

@@ -1 +0,0 @@
-.rules

.zed/settings.json

@@ -45,6 +45,5 @@
   "hard_tabs": false,
   "formatter": "auto",
   "remove_trailing_whitespace_on_save": true,
-  "ensure_final_newline_on_save": true,
-  "file_scan_exclusions": ["crates/eval/worktrees/", "crates/eval/repos/"]
+  "ensure_final_newline_on_save": true
 }

CLAUDE.md

@@ -1 +0,0 @@
-.rules

Cargo.lock

@@ -1344,13 +1344,12 @@ dependencies = [
 
 [[package]]
 name = "aws-sdk-bedrockruntime"
-version = "1.82.0"
+version = "1.80.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8cb95f77abd4321348dd2f52a25e1de199732f54d2a35860ad20f5df21c66b44"
+checksum = "39ee8ef191b908d013659ca2c0670215f0c920c781998e1dc55904d6bdb73b51"
 dependencies = [
  "aws-credential-types",
  "aws-runtime",
- "aws-sigv4",
  "aws-smithy-async",
  "aws-smithy-eventstream",
  "aws-smithy-http",
@@ -1362,7 +1361,6 @@ dependencies = [
  "bytes 1.10.1",
  "fastrand 2.3.0",
  "http 0.2.12",
- "hyper 0.14.32",
  "once_cell",
  "regex-lite",
  "tracing",
@@ -2726,9 +2724,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.36"
+version = "4.5.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2df961d8c8a0d08aa9945718ccf584145eee3f3aa06cddbeac12933781102e04"
+checksum = "d8aa86934b44c19c50f87cc2790e19f54f7a67aedb64101c2e1a2e5ecfb73944"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -2736,9 +2734,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.36"
+version = "4.5.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "132dbda40fb6753878316a489d5a1242a8ef2f0d9e47ba01c951ea8aa7d013a5"
+checksum = "2414dbb2dd0695280da6ea9261e327479e9d37b0630f6b53ba2a11c60c679fd9"
 dependencies = [
  "anstream",
  "anstyle",
@@ -4918,6 +4916,7 @@ dependencies = [
  "release_channel",
  "reqwest_client",
  "serde",
+ "serde_json",
  "settings",
  "shellexpand 2.1.2",
  "telemetry",
@@ -4925,7 +4924,6 @@ dependencies = [
  "unindent",
  "util",
  "uuid",
- "workspace-hack",
 ]
 
 [[package]]
@@ -6171,7 +6169,6 @@ dependencies = [
  "windows 0.61.1",
  "windows-core 0.61.0",
  "windows-numerics",
- "windows-registry 0.5.1",
  "workspace-hack",
  "x11-clipboard",
  "x11rb",
@@ -7114,12 +7111,10 @@ dependencies = [
 name = "inline_completion"
 version = "0.1.0"
 dependencies = [
- "anyhow",
  "gpui",
  "language",
  "project",
  "workspace-hack",
- "zed_llm_client",
 ]
 
 [[package]]
@@ -7150,7 +7145,6 @@ dependencies = [
  "workspace",
  "workspace-hack",
  "zed_actions",
- "zed_llm_client",
  "zeta",
 ]
 
@@ -7652,6 +7646,7 @@ dependencies = [
  "http_client",
  "icons",
  "image",
+ "log",
  "open_ai",
  "parking_lot",
  "proto",
@@ -7890,9 +7885,9 @@ checksum = "03087c2bad5e1034e8cace5926dec053fb3790248370865f5117a7d0213354c8"
 
 [[package]]
 name = "libc"
-version = "0.2.172"
+version = "0.2.171"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
+checksum = "c19937216e9d3aa9956d9bb8dfc0b0c8beb6058fc4f7a4dc4d850edf86a237d6"
 
 [[package]]
 name = "libdbus-sys"
@@ -7944,9 +7939,9 @@ checksum = "8355be11b20d696c8f18f6cc018c4e372165b1fa8126cef092399c9951984ffa"
 
 [[package]]
 name = "libmimalloc-sys"
-version = "0.1.42"
+version = "0.1.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec9d6fac27761dabcd4ee73571cdb06b7022dc99089acbe5435691edffaac0f4"
+checksum = "6b20daca3a4ac14dbdc753c5e90fc7b490a48a9131daed3c9a9ced7b2defd37b"
 dependencies = [
  "cc",
  "libc",
@@ -8617,9 +8612,9 @@ dependencies = [
 
 [[package]]
 name = "mimalloc"
-version = "0.1.46"
+version = "0.1.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "995942f432bbb4822a7e9c3faa87a695185b0d09273ba85f097b54f4e458f2af"
+checksum = "03cb1f88093fe50061ca1195d336ffec131347c7b833db31f9ab62a2d1b7925f"
 dependencies = [
  "libmimalloc-sys",
 ]
@@ -10789,9 +10784,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.95"
+version = "1.0.94"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
+checksum = "a31971752e70b8b2686d7e46ec17fb38dad4051d94024c88df49b667caea9c84"
 dependencies = [
  "unicode-ident",
 ]
@@ -11931,7 +11926,7 @@ dependencies = [
  "wasm-bindgen-futures",
  "wasm-streams",
  "web-sys",
- "windows-registry 0.2.0",
+ "windows-registry",
 ]
 
 [[package]]
@@ -12629,9 +12624,9 @@ dependencies = [
 
 [[package]]
 name = "sea-orm"
-version = "1.1.10"
+version = "1.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21e61af841881c137d4bc8e0d8411cee9168548b404f9e4788e8af7e8f94bd4e"
+checksum = "013d6c9e421b9c44c6eb6ebbee283b2a2c90eab2682088c4a2449706a42d117f"
 dependencies = [
  "async-stream",
  "async-trait",
@@ -12658,9 +12653,9 @@ dependencies = [
 
 [[package]]
 name = "sea-orm-macros"
-version = "1.1.10"
+version = "1.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6b86e3e77b548e6c6c1f612a1ca024d557dffdb81b838bf482ad3222140c77b"
+checksum = "31feeff3ad5e999c64b2b8fd30933b2871911567c4d62dcf70b3effd970c7891"
 dependencies = [
  "heck 0.4.1",
  "proc-macro2",
@@ -13442,9 +13437,9 @@ dependencies = [
 
 [[package]]
 name = "sqlx"
-version = "0.8.5"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3c3a85280daca669cfd3bcb68a337882a8bc57ec882f72c5d13a430613a738e"
+checksum = "4410e73b3c0d8442c5f99b425d7a435b5ee0ae4167b3196771dd3f7a01be745f"
 dependencies = [
  "sqlx-core",
  "sqlx-macros",
@@ -13455,11 +13450,10 @@ dependencies = [
 
 [[package]]
 name = "sqlx-core"
-version = "0.8.5"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f743f2a3cea30a58cd479013f75550e879009e3a02f616f18ca699335aa248c3"
+checksum = "6a007b6936676aa9ab40207cde35daab0a04b823be8ae004368c0793b96a61e0"
 dependencies = [
- "base64 0.22.1",
  "bigdecimal",
  "bytes 1.10.1",
  "chrono",
@@ -13480,6 +13474,7 @@ dependencies = [
  "percent-encoding",
  "rust_decimal",
  "rustls 0.23.26",
+ "rustls-pemfile 2.2.0",
  "serde",
  "serde_json",
  "sha2",
@@ -13496,9 +13491,9 @@ dependencies = [
 
 [[package]]
 name = "sqlx-macros"
-version = "0.8.5"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f4200e0fde19834956d4252347c12a083bdcb237d7a1a1446bffd8768417dce"
+checksum = "3112e2ad78643fef903618d78cf0aec1cb3134b019730edb039b69eaf531f310"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -13509,9 +13504,9 @@ dependencies = [
 
 [[package]]
 name = "sqlx-macros-core"
-version = "0.8.5"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "882ceaa29cade31beca7129b6beeb05737f44f82dbe2a9806ecea5a7093d00b7"
+checksum = "4e9f90acc5ab146a99bf5061a7eb4976b573f560bc898ef3bf8435448dd5e7ad"
 dependencies = [
  "dotenvy",
  "either",
@@ -13535,9 +13530,9 @@ dependencies = [
 
 [[package]]
 name = "sqlx-mysql"
-version = "0.8.5"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0afdd3aa7a629683c2d750c2df343025545087081ab5942593a5288855b1b7a7"
+checksum = "4560278f0e00ce64938540546f59f590d60beee33fffbd3b9cd47851e5fff233"
 dependencies = [
  "atoi",
  "base64 0.22.1",
@@ -13582,9 +13577,9 @@ dependencies = [
 
 [[package]]
 name = "sqlx-postgres"
-version = "0.8.5"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0bedbe1bbb5e2615ef347a5e9d8cd7680fb63e77d9dafc0f29be15e53f1ebe6"
+checksum = "c5b98a57f363ed6764d5b3a12bfedf62f07aa16e1856a7ddc2a0bb190a959613"
 dependencies = [
  "atoi",
  "base64 0.22.1",
@@ -13625,9 +13620,9 @@ dependencies = [
 
 [[package]]
 name = "sqlx-sqlite"
-version = "0.8.5"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c26083e9a520e8eb87a06b12347679b142dc2ea29e6e409f805644a7a979a5bc"
+checksum = "f85ca71d3a5b24e64e1d08dd8fe36c6c95c339a896cc33068148906784620540"
 dependencies = [
  "atoi",
  "chrono",
@@ -13643,7 +13638,6 @@ dependencies = [
  "serde",
  "serde_urlencoded",
  "sqlx-core",
- "thiserror 2.0.12",
  "time",
  "tracing",
  "url",
@@ -15839,6 +15833,7 @@ dependencies = [
  "indoc",
  "itertools 0.14.0",
  "language",
+ "libc",
  "log",
  "lsp",
  "multi_buffer",
@@ -17045,17 +17040,6 @@ dependencies = [
  "windows-targets 0.52.6",
 ]
 
-[[package]]
-name = "windows-registry"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad1da3e436dc7653dfdf3da67332e22bff09bb0e28b0239e1624499c7830842e"
-dependencies = [
- "windows-link",
- "windows-result 0.3.2",
- "windows-strings 0.4.0",
-]
-
 [[package]]
 name = "windows-result"
 version = "0.1.2"
@@ -18337,7 +18321,6 @@ dependencies = [
  "gpui",
  "schemars",
  "serde",
- "uuid",
  "workspace-hack",
 ]
 
@@ -18384,9 +18367,9 @@ dependencies = [
 
 [[package]]
 name = "zed_llm_client"
-version = "0.6.1"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad17428120f5ca776dc5195e2411a282f5150a26d5536671f8943c622c31274f"
+checksum = "b91b8b05f1028157205026e525869eb860fa89bec87ea60b445efc91d05df31f"
 dependencies = [
  "anyhow",
  "serde",

Cargo.toml

@@ -604,7 +604,7 @@ wasmtime-wasi = "29"
 which = "6.0.0"
 wit-component = "0.221"
 workspace-hack = "0.1.0"
-zed_llm_client = "0.6.1"
+zed_llm_client = "0.6.0"
 zstd = "0.11"
 metal = "0.29"
 

Dockerfile-cross

@@ -11,7 +11,7 @@ ENV CARGO_TERM_COLOR=always
 
 COPY script/install-mold script/
 RUN ./script/install-mold "2.34.0"
-COPY script/remote-server script/
-RUN ./script/remote-server
+COPY script/headless script/
+RUN ./script/headless
 
 COPY . .

assets/keymaps/default-linux.json

@@ -49,6 +49,15 @@
       "down": "menu::SelectNext"
     }
   },
+  {
+    "context": "Prompt",
+    "bindings": {
+      "left": "menu::SelectPrevious",
+      "right": "menu::SelectNext",
+      "h": "menu::SelectPrevious",
+      "l": "menu::SelectNext"
+    }
+  },
   {
     "context": "Editor",
     "bindings": {
@@ -130,6 +139,24 @@
       "ctrl-shift-alt-backspace": "editor::GoToNextChange"
     }
   },
+  {
+    "context": "Editor && !agent_diff",
+    "bindings": {
+      "ctrl-k ctrl-r": "git::Restore",
+      "ctrl-alt-y": "git::ToggleStaged",
+      "alt-y": "git::StageAndNext",
+      "alt-shift-y": "git::UnstageAndNext"
+    }
+  },
+  {
+    "context": "AgentDiff",
+    "bindings": {
+      "ctrl-y": "agent::Keep",
+      "ctrl-n": "agent::Reject",
+      "ctrl-shift-y": "agent::KeepAll",
+      "ctrl-shift-n": "agent::RejectAll"
+    }
+  },
   {
     "context": "Editor && mode == full",
     "bindings": {
@@ -178,31 +205,6 @@
       "ctrl-c": "markdown::Copy"
     }
   },
-  {
-    "context": "Editor && jupyter && !ContextEditor",
-    "bindings": {
-      "ctrl-shift-enter": "repl::Run",
-      "ctrl-alt-enter": "repl::RunInPlace"
-    }
-  },
-  {
-    "context": "Editor && !agent_diff",
-    "bindings": {
-      "ctrl-k ctrl-r": "git::Restore",
-      "ctrl-alt-y": "git::ToggleStaged",
-      "alt-y": "git::StageAndNext",
-      "alt-shift-y": "git::UnstageAndNext"
-    }
-  },
-  {
-    "context": "AgentDiff",
-    "bindings": {
-      "ctrl-y": "agent::Keep",
-      "ctrl-n": "agent::Reject",
-      "ctrl-shift-y": "agent::KeepAll",
-      "ctrl-shift-n": "agent::RejectAll"
-    }
-  },
   {
     "context": "AssistantPanel",
     "bindings": {
@@ -218,93 +220,6 @@
       "ctrl-n": "assistant::NewChat"
     }
   },
-  {
-    "context": "ContextEditor > Editor",
-    "bindings": {
-      "ctrl-enter": "assistant::Assist",
-      "ctrl-shift-enter": "assistant::Edit",
-      "ctrl-s": "workspace::Save",
-      "save": "workspace::Save",
-      "ctrl->": "assistant::QuoteSelection",
-      "ctrl-<": "assistant::InsertIntoEditor",
-      "ctrl-alt-/": "assistant::ToggleModelSelector",
-      "shift-enter": "assistant::Split",
-      "ctrl-r": "assistant::CycleMessageRole",
-      "enter": "assistant::ConfirmCommand",
-      "alt-enter": "editor::Newline"
-    }
-  },
-  {
-    "context": "AgentPanel",
-    "bindings": {
-      "ctrl-n": "agent::NewThread",
-      "ctrl-alt-n": "agent::NewTextThread",
-      "ctrl-shift-h": "agent::OpenHistory",
-      "ctrl-alt-c": "agent::OpenConfiguration",
-      "ctrl-alt-p": "assistant::OpenPromptLibrary",
-      "ctrl-i": "agent::ToggleProfileSelector",
-      "ctrl-alt-/": "assistant::ToggleModelSelector",
-      "ctrl-shift-a": "agent::ToggleContextPicker",
-      "shift-escape": "agent::ExpandMessageEditor",
-      "ctrl-e": "agent::ChatMode",
-      "ctrl-alt-e": "agent::RemoveAllContext"
-    }
-  },
-  {
-    "context": "AgentPanel > Markdown",
-    "bindings": {
-      "copy": "markdown::CopyAsMarkdown",
-      "ctrl-c": "markdown::CopyAsMarkdown"
-    }
-  },
-  {
-    "context": "AgentPanel && prompt_editor",
-    "bindings": {
-      "cmd-n": "agent::NewTextThread",
-      "cmd-alt-t": "agent::NewThread"
-    }
-  },
-  {
-    "context": "MessageEditor > Editor",
-    "bindings": {
-      "enter": "agent::Chat",
-      "ctrl-i": "agent::ToggleProfileSelector",
-      "shift-ctrl-r": "agent::OpenAgentDiff"
-    }
-  },
-  {
-    "context": "EditMessageEditor > Editor",
-    "bindings": {
-      "escape": "menu::Cancel",
-      "enter": "menu::Confirm",
-      "alt-enter": "editor::Newline"
-    }
-  },
-  {
-    "context": "AgentFeedbackMessageEditor > Editor",
-    "bindings": {
-      "escape": "menu::Cancel",
-      "enter": "menu::Confirm",
-      "alt-enter": "editor::Newline"
-    }
-  },
-  {
-    "context": "ContextStrip",
-    "bindings": {
-      "up": "agent::FocusUp",
-      "right": "agent::FocusRight",
-      "left": "agent::FocusLeft",
-      "down": "agent::FocusDown",
-      "backspace": "agent::RemoveFocusedContext",
-      "enter": "agent::AcceptSuggestedContext"
-    }
-  },
-  {
-    "context": "ThreadHistory",
-    "bindings": {
-      "backspace": "agent::RemoveSelectedThread"
-    }
-  },
   {
     "context": "PromptLibrary",
     "bindings": {
@@ -687,6 +602,100 @@
       "ctrl-:": "editor::ToggleInlayHints"
     }
   },
+  {
+    "context": "Editor && jupyter && !ContextEditor",
+    "bindings": {
+      "ctrl-shift-enter": "repl::Run",
+      "ctrl-alt-enter": "repl::RunInPlace"
+    }
+  },
+  {
+    "context": "ContextEditor > Editor",
+    "bindings": {
+      "ctrl-enter": "assistant::Assist",
+      "ctrl-shift-enter": "assistant::Edit",
+      "ctrl-s": "workspace::Save",
+      "save": "workspace::Save",
+      "ctrl->": "assistant::QuoteSelection",
+      "ctrl-<": "assistant::InsertIntoEditor",
+      "ctrl-alt-/": "assistant::ToggleModelSelector",
+      "shift-enter": "assistant::Split",
+      "ctrl-r": "assistant::CycleMessageRole",
+      "enter": "assistant::ConfirmCommand",
+      "alt-enter": "editor::Newline"
+    }
+  },
+  {
+    "context": "AgentPanel",
+    "bindings": {
+      "ctrl-n": "agent::NewThread",
+      "ctrl-alt-n": "agent::NewTextThread",
+      "ctrl-shift-h": "agent::OpenHistory",
+      "ctrl-alt-c": "agent::OpenConfiguration",
+      "ctrl-alt-p": "assistant::OpenPromptLibrary",
+      "ctrl-i": "agent::ToggleProfileSelector",
+      "ctrl-alt-/": "assistant::ToggleModelSelector",
+      "ctrl-shift-a": "agent::ToggleContextPicker",
+      "shift-escape": "agent::ExpandMessageEditor",
+      "ctrl-e": "agent::ChatMode",
+      "ctrl-alt-e": "agent::RemoveAllContext"
+    }
+  },
+  {
+    "context": "AgentPanel > Markdown",
+    "bindings": {
+      "copy": "markdown::CopyAsMarkdown",
+      "ctrl-c": "markdown::CopyAsMarkdown"
+    }
+  },
+  {
+    "context": "AgentPanel && prompt_editor",
+    "bindings": {
+      "cmd-n": "agent::NewTextThread",
+      "cmd-alt-t": "agent::NewThread"
+    }
+  },
+  {
+    "context": "MessageEditor > Editor",
+    "bindings": {
+      "enter": "agent::Chat",
+      "ctrl-i": "agent::ToggleProfileSelector",
+      "shift-ctrl-r": "agent::OpenAgentDiff"
+    }
+  },
+  {
+    "context": "EditMessageEditor > Editor",
+    "bindings": {
+      "escape": "menu::Cancel",
+      "enter": "menu::Confirm",
+      "alt-enter": "editor::Newline"
+    }
+  },
+  {
+    "context": "AgentFeedbackMessageEditor > Editor",
+    "bindings": {
+      "escape": "menu::Cancel",
+      "enter": "menu::Confirm",
+      "alt-enter": "editor::Newline"
+    }
+  },
+  {
+    "context": "ContextStrip",
+    "bindings": {
+      "up": "agent::FocusUp",
+      "right": "agent::FocusRight",
+      "left": "agent::FocusLeft",
+      "down": "agent::FocusDown",
+      "backspace": "agent::RemoveFocusedContext",
+      "enter": "agent::AcceptSuggestedContext"
+    }
+  },
+  {
+    "context": "ThreadHistory",
+    "bindings": {
+      "backspace": "agent::RemoveSelectedThread"
+    }
+  },
   {
     "context": "PromptEditor",
     "bindings": {
@@ -695,15 +704,6 @@
       "ctrl-alt-e": "agent::RemoveAllContext"
     }
   },
-  {
-    "context": "Prompt",
-    "bindings": {
-      "left": "menu::SelectPrevious",
-      "right": "menu::SelectNext",
-      "h": "menu::SelectPrevious",
-      "l": "menu::SelectNext"
-    }
-  },
   {
     "context": "ProjectSearchBar && !in_replace",
     "bindings": {
@@ -920,7 +920,6 @@
       "ctrl-enter": "assistant::InlineAssist",
       "alt-b": ["terminal::SendText", "\u001bb"],
       "alt-f": ["terminal::SendText", "\u001bf"],
-      "alt-.": ["terminal::SendText", "\u001b."],
       // Overrides for conflicting keybindings
       "ctrl-b": ["terminal::SendKeystroke", "ctrl-b"],
       "ctrl-c": ["terminal::SendKeystroke", "ctrl-c"],

assets/keymaps/default-macos.json

@@ -1005,7 +1005,6 @@
       "alt-right": ["terminal::SendText", "\u001bf"],
       "alt-b": ["terminal::SendText", "\u001bb"],
       "alt-f": ["terminal::SendText", "\u001bf"],
-      "alt-.": ["terminal::SendText", "\u001b."],
       // There are conflicting bindings for these keys in the global context.
       // these bindings override them, remove at your own risk:
       "up": ["terminal::SendKeystroke", "up"],

assets/prompts/assistant_system_prompt.hbs

@@ -8,6 +8,16 @@ You are a highly skilled software engineer with extensive knowledge in many prog
 4. NEVER lie or make things up.
 5. Refrain from apologizing all the time when results are unexpected. Instead, just try your best to proceed or explain the circumstances to the user without apologizing.
 
+## Searching and Reading
+
+If you are unsure about the answer to the user's request or how to satiate their request, you should gather more information.
+This can be done with additional tool calls, asking clarifying questions, etc.
+
+For example, if you've performed a semantic search, and the results may not fully answer the user's request, or merit gathering more information, feel free to call more tools. Similarly, if you've performed an edit that may partially
+satiate the user's query, but you're not confident, gather more information or use more tools before ending your turn.
+
+Bias towards not asking the user for help if you can find the answer yourself.
+
 ## Tool Use
 
 1. Make sure to adhere to the tools schema.
@@ -16,22 +26,6 @@ You are a highly skilled software engineer with extensive knowledge in many prog
 4. Use only the tools that are currently available.
 5. DO NOT use a tool that is not available just because it appears in the conversation. This means the user turned it off.
 
-## Searching and Reading
-
-If you are unsure how to fulfill the user's request, gather more information with tool calls and/or clarifying questions.
-
-{{! TODO: If there are files, we should mention it but otherwise omit that fact }}
-If appropriate, use tool calls to explore the current project, which contains the following root directories:
-
-{{#each worktrees}}
-- `{{root_name}}`
-{{/each}}
-
-- When providing paths to tools, the path should always begin with a path that starts with a project root directory listed above.
-- When looking for symbols in the project, prefer the `grep` tool.
-- As you learn about the structure of the project, use that information to scope `grep` searches to targeted subtrees of the project.
-- Bias towards not asking the user for help if you can find the answer yourself.
-
 ## Fixing Diagnostics
 
 1. Make 1-2 attempts at fixing diagnostics, then defer to the user.
@@ -56,13 +50,19 @@ Otherwise, follow debugging best practices:
 Operating System: {{os}}
 Default Shell: {{shell}}
 
-{{#if (or has_rules has_default_user_rules)}}
+The user has opened a project that contains the following root directories/files. Whenever you specify a path in the project, it must be a relative path which begins with one of these root directories/files:
+
+{{#each worktrees}}
+- `{{root_name}}` (absolute path: `{{abs_path}}`)
+{{/each}}
+
+{{#if has_rules}}
+
 ## User's Custom Instructions
 
 The following additional instructions are provided by the user, and should be followed to the best of your ability without interfering with the tool use guidelines.
 
-{{#if has_rules}}
-There are project rules that apply to these root directories:
+There are rules that apply to these root directories:
 {{#each worktrees}}
 {{#if rules_file}}
 `{{root_name}}/{{rules_file.path_in_worktree}}`:
@@ -72,17 +72,3 @@ There are project rules that apply to these root directories:
 {{/if}}
 {{/each}}
 {{/if}}
-
-{{#if has_default_user_rules}}
-The user has specified the following rules that should be applied:
-{{#each default_user_rules}}
-
-{{#if title}}
-Rules title: {{title}}
-{{/if}}
-``````
-{{contents}}}
-``````
-{{/each}}
-{{/if}}
-{{/if}}

assets/settings/default.json

@@ -181,6 +181,8 @@
   "current_line_highlight": "all",
   // Whether to highlight all occurrences of the selected text in an editor.
   "selection_highlight": true,
+  // The debounce delay before querying highlights based on the selected text.
+  "selection_highlight_debounce": 50,
   // The debounce delay before querying highlights from the language
   // server based on the current cursor location.
   "lsp_highlight_debounce": 75,
@@ -212,7 +214,14 @@
   // The default number of lines to expand excerpts in the multibuffer by.
   "expand_excerpt_lines": 3,
   // Globs to match against file paths to determine if a file is private.
-  "private_files": ["**/.env*", "**/*.pem", "**/*.key", "**/*.cert", "**/*.crt", "**/secrets.yml"],
+  "private_files": [
+    "**/.env*",
+    "**/*.pem",
+    "**/*.key",
+    "**/*.cert",
+    "**/*.crt",
+    "**/secrets.yml"
+  ],
   // Whether to use additional LSP queries to format (and amend) the code after
   // every "trigger" symbol input, defined by LSP server capabilities.
   "use_on_type_format": true,
@@ -648,7 +657,7 @@
           "now": true,
           "path_search": true,
           "read_file": true,
-          "grep": true,
+          "regex_search": true,
           "thinking": true,
           "web_search": true
         }
@@ -672,7 +681,7 @@
           "now": false,
           "path_search": true,
           "read_file": true,
-          "grep": true,
+          "regex_search": true,
           "rename": false,
           "symbol_info": false,
           "terminal": true,
@@ -712,7 +721,9 @@
   // The list of language servers to use (or disable) for all languages.
   //
   // This is typically customized on a per-language basis.
-  "language_servers": ["..."],
+  "language_servers": [
+    "..."
+  ],
   // When to automatically save edited buffers. This setting can
   // take four values.
   //
@@ -908,7 +919,9 @@
   // for files that are not tracked by git, but are still important to your project. Note that globs
   // that are overly broad can slow down Zed's file scanning. `file_scan_exclusions` takes
   // precedence over these inclusions.
-  "file_scan_inclusions": [".env*"],
+  "file_scan_inclusions": [
+    ".env*"
+  ],
   // Git gutter behavior configuration.
   "git": {
     // Control whether the git gutter is shown. May take 2 values:
@@ -960,7 +973,15 @@
     // Any addition to this list will be merged with the default list.
     // Globs are matched relative to the worktree root,
     // except when starting with a slash (/) or equivalent in Windows.
-    "disabled_globs": ["**/.env*", "**/*.pem", "**/*.key", "**/*.cert", "**/*.crt", "**/.dev.vars", "**/secrets.yml"],
+    "disabled_globs": [
+      "**/.env*",
+      "**/*.pem",
+      "**/*.key",
+      "**/*.cert",
+      "**/*.crt",
+      "**/.dev.vars",
+      "**/secrets.yml"
+    ],
     // When to show edit predictions previews in buffer.
     // This setting takes two possible values:
     // 1. Display predictions inline when there are no language server completions available.
@@ -1093,7 +1114,12 @@
         // Default directories to search for virtual environments, relative
         // to the current working directory. We recommend overriding this
         // in your project's settings, rather than globally.
-        "directories": [".env", "env", ".venv", "venv"],
+        "directories": [
+          ".env",
+          "env",
+          ".venv",
+          "venv"
+        ],
         // Can also be `csh`, `fish`, `nushell` and `power_shell`
         "activate_script": "default"
       }
@@ -1157,8 +1183,15 @@
   // }
   //
   "file_types": {
-    "JSONC": ["**/.zed/**/*.json", "**/zed/**/*.json", "**/Zed/**/*.json", "**/.vscode/**/*.json"],
-    "Shell Script": [".env.*"]
+    "JSONC": [
+      "**/.zed/**/*.json",
+      "**/zed/**/*.json",
+      "**/Zed/**/*.json",
+      "**/.vscode/**/*.json"
+    ],
+    "Shell Script": [
+      ".env.*"
+    ]
   },
   // By default use a recent system version of node, or install our own.
   // You can override this to use a version of node that is not in $PATH with:
@@ -1231,10 +1264,15 @@
   // Different settings for specific languages.
   "languages": {
     "Astro": {
-      "language_servers": ["astro-language-server", "..."],
+      "language_servers": [
+        "astro-language-server",
+        "..."
+      ],
       "prettier": {
         "allowed": true,
-        "plugins": ["prettier-plugin-astro"]
+        "plugins": [
+          "prettier-plugin-astro"
+        ]
       }
     },
     "Blade": {
@@ -1270,10 +1308,19 @@
       "ensure_final_newline_on_save": false
     },
     "Elixir": {
-      "language_servers": ["elixir-ls", "!next-ls", "!lexical", "..."]
+      "language_servers": [
+        "elixir-ls",
+        "!next-ls",
+        "!lexical",
+        "..."
+      ]
     },
     "Erlang": {
-      "language_servers": ["erlang-ls", "!elp", "..."]
+      "language_servers": [
+        "erlang-ls",
+        "!elp",
+        "..."
+      ]
     },
     "Git Commit": {
       "allow_rewrap": "anywhere"
@@ -1289,7 +1336,12 @@
       }
     },
     "HEEX": {
-      "language_servers": ["elixir-ls", "!next-ls", "!lexical", "..."]
+      "language_servers": [
+        "elixir-ls",
+        "!next-ls",
+        "!lexical",
+        "..."
+      ]
     },
     "HTML": {
       "prettier": {
@@ -1299,11 +1351,17 @@
     "Java": {
       "prettier": {
         "allowed": true,
-        "plugins": ["prettier-plugin-java"]
+        "plugins": [
+          "prettier-plugin-java"
+        ]
       }
     },
     "JavaScript": {
-      "language_servers": ["!typescript-language-server", "vtsls", "..."],
+      "language_servers": [
+        "!typescript-language-server",
+        "vtsls",
+        "..."
+      ],
       "prettier": {
         "allowed": true
       }
@@ -1321,7 +1379,10 @@
     "LaTeX": {
       "format_on_save": "on",
       "formatter": "language_server",
-      "language_servers": ["texlab", "..."],
+      "language_servers": [
+        "texlab",
+        "..."
+      ],
       "prettier": {
         "allowed": false
       }
@@ -1336,10 +1397,16 @@
       }
     },
     "PHP": {
-      "language_servers": ["phpactor", "!intelephense", "..."],
+      "language_servers": [
+        "phpactor",
+        "!intelephense",
+        "..."
+      ],
       "prettier": {
         "allowed": true,
-        "plugins": ["@prettier/plugin-php"],
+        "plugins": [
+          "@prettier/plugin-php"
+        ],
         "parser": "php"
       }
     },
@@ -1347,7 +1414,12 @@
       "allow_rewrap": "anywhere"
     },
     "Ruby": {
-      "language_servers": ["solargraph", "!ruby-lsp", "!rubocop", "..."]
+      "language_servers": [
+        "solargraph",
+        "!ruby-lsp",
+        "!rubocop",
+        "..."
+      ]
     },
     "SCSS": {
       "prettier": {
@@ -1357,21 +1429,36 @@
     "SQL": {
       "prettier": {
         "allowed": true,
-        "plugins": ["prettier-plugin-sql"]
+        "plugins": [
+          "prettier-plugin-sql"
+        ]
       }
     },
     "Starlark": {
-      "language_servers": ["starpls", "!buck2-lsp", "..."]
+      "language_servers": [
+        "starpls",
+        "!buck2-lsp",
+        "..."
+      ]
     },
     "Svelte": {
-      "language_servers": ["svelte-language-server", "..."],
+      "language_servers": [
+        "svelte-language-server",
+        "..."
+      ],
       "prettier": {
         "allowed": true,
-        "plugins": ["prettier-plugin-svelte"]
+        "plugins": [
+          "prettier-plugin-svelte"
+        ]
       }
     },
     "TSX": {
-      "language_servers": ["!typescript-language-server", "vtsls", "..."],
+      "language_servers": [
+        "!typescript-language-server",
+        "vtsls",
+        "..."
+      ],
       "prettier": {
         "allowed": true
       }
@@ -1382,13 +1469,20 @@
       }
     },
     "TypeScript": {
-      "language_servers": ["!typescript-language-server", "vtsls", "..."],
+      "language_servers": [
+        "!typescript-language-server",
+        "vtsls",
+        "..."
+      ],
       "prettier": {
         "allowed": true
       }
     },
     "Vue.js": {
-      "language_servers": ["vue-language-server", "..."],
+      "language_servers": [
+        "vue-language-server",
+        "..."
+      ],
       "prettier": {
         "allowed": true
       }
@@ -1396,7 +1490,9 @@
     "XML": {
       "prettier": {
         "allowed": true,
-        "plugins": ["@prettier/plugin-xml"]
+        "plugins": [
+          "@prettier/plugin-xml"
+        ]
       }
     },
     "YAML": {
@@ -1405,7 +1501,10 @@
       }
     },
     "Zig": {
-      "language_servers": ["zls", "..."]
+      "language_servers": [
+        "zls",
+        "..."
+      ]
     }
   },
   // Different settings for specific language models.

crates/agent/src/active_thread.rs

@@ -1,8 +1,8 @@
 use crate::context::{AssistantContext, ContextId, format_context_as_string};
 use crate::context_picker::MentionLink;
 use crate::thread::{
-    LastRestoreCheckpoint, MessageId, MessageSegment, Thread, ThreadError, ThreadEvent,
-    ThreadFeedback,
+    LastRestoreCheckpoint, MessageId, MessageSegment, RequestKind, Thread, ThreadError,
+    ThreadEvent, ThreadFeedback,
 };
 use crate::thread_store::{RulesLoadingError, ThreadStore};
 use crate::tool_use::{PendingToolUseStatus, ToolUse};
@@ -42,7 +42,6 @@ use ui::{
 };
 use util::ResultExt as _;
 use workspace::{OpenOptions, Workspace};
-use zed_actions::assistant::OpenPromptLibrary;
 
 use crate::context_store::ContextStore;
 
@@ -133,23 +132,18 @@ impl RenderedMessage {
     }
 
     fn push_segment(&mut self, segment: &MessageSegment, cx: &mut App) {
-        match segment {
-            MessageSegment::Thinking { text, .. } => {
-                self.segments.push(RenderedMessageSegment::Thinking {
-                    content: parse_markdown(text.into(), self.language_registry.clone(), cx),
-                    scroll_handle: ScrollHandle::default(),
-                })
-            }
-            MessageSegment::Text(text) => {
-                self.segments
-                    .push(RenderedMessageSegment::Text(parse_markdown(
-                        text.into(),
-                        self.language_registry.clone(),
-                        cx,
-                    )))
-            }
-            MessageSegment::RedactedThinking(_) => {}
+        let rendered_segment = match segment {
+            MessageSegment::Thinking(text) => RenderedMessageSegment::Thinking {
+                content: parse_markdown(text.into(), self.language_registry.clone(), cx),
+                scroll_handle: ScrollHandle::default(),
+            },
+            MessageSegment::Text(text) => RenderedMessageSegment::Text(parse_markdown(
+                text.into(),
+                self.language_registry.clone(),
+                cx,
+            )),
         };
+        self.segments.push(rendered_segment);
     }
 }
 
@@ -508,6 +502,7 @@ fn render_markdown_code_block(
         .blend(cx.theme().colors().editor_foreground.opacity(0.01));
 
     let codeblock_header = h_flex()
+        .group("codeblock_header")
         .py_1()
         .pl_1p5()
         .pr_1()
@@ -522,7 +517,7 @@ fn render_markdown_code_block(
             h_flex()
                 .gap_1()
                 .child(
-                    div().visible_on_hover("codeblock_container").child(
+                    div().visible_on_hover("codeblock_header").child(
                         IconButton::new(
                             ("copy-markdown-code", ix),
                             if codeblock_was_copied {
@@ -604,7 +599,6 @@ fn render_markdown_code_block(
         );
 
     v_flex()
-        .group("codeblock_container")
         .my_2()
         .overflow_hidden()
         .rounded_lg()
@@ -1217,8 +1211,6 @@ impl ActiveThread {
                 }
 
                 let request = language_model::LanguageModelRequest {
-                    thread_id: None,
-                    prompt_id: None,
                     messages: vec![LanguageModelRequestMessage {
                         role: language_model::Role::User,
                         content: vec![content.into()],
@@ -1284,8 +1276,7 @@ impl ActiveThread {
         }
 
         self.thread.update(cx, |thread, cx| {
-            thread.advance_prompt_id();
-            thread.send_to_model(model.model, cx)
+            thread.send_to_model(model.model, RequestKind::Chat, cx)
         });
         cx.notify();
     }
@@ -2957,116 +2948,53 @@ impl ActiveThread {
             return div().into_any();
         };
 
-        let default_user_rules_text = if project_context.default_user_rules.is_empty() {
-            None
-        } else if project_context.default_user_rules.len() == 1 {
-            let user_rules = &project_context.default_user_rules[0];
-
-            match user_rules.title.as_ref() {
-                Some(title) => Some(format!("Using \"{title}\" user rule")),
-                None => Some("Using user rule".into()),
-            }
-        } else {
-            Some(format!(
-                "Using {} user rules",
-                project_context.default_user_rules.len()
-            ))
-        };
-
-        let first_default_user_rules_id = project_context
-            .default_user_rules
-            .first()
-            .map(|user_rules| user_rules.uuid);
-
         let rules_files = project_context
             .worktrees
             .iter()
             .filter_map(|worktree| worktree.rules_file.as_ref())
             .collect::<Vec<_>>();
 
-        let rules_file_text = match rules_files.as_slice() {
-            &[] => None,
-            &[rules_file] => Some(format!(
-                "Using project {:?} file",
-                rules_file.path_in_worktree
-            )),
-            rules_files => Some(format!("Using {} project rules files", rules_files.len())),
+        let label_text = match rules_files.as_slice() {
+            &[] => return div().into_any(),
+            &[rules_file] => {
+                format!("Using {:?} file", rules_file.path_in_worktree)
+            }
+            rules_files => {
+                format!("Using {} rules files", rules_files.len())
+            }
         };
 
-        if default_user_rules_text.is_none() && rules_file_text.is_none() {
-            return div().into_any();
-        }
-
-        v_flex()
+        div()
             .pt_2()
             .px_2p5()
-            .gap_1()
-            .when_some(
-                default_user_rules_text,
-                |parent, default_user_rules_text| {
-                    parent.child(
+            .child(
+                h_flex()
+                    .w_full()
+                    .gap_0p5()
+                    .child(
                         h_flex()
-                            .w_full()
+                            .gap_1p5()
                             .child(
                                 Icon::new(IconName::File)
                                     .size(IconSize::XSmall)
                                     .color(Color::Disabled),
                             )
                             .child(
-                                Label::new(default_user_rules_text)
+                                Label::new(label_text)
                                     .size(LabelSize::XSmall)
                                     .color(Color::Muted)
-                                    .truncate()
-                                    .buffer_font(cx)
-                                    .ml_1p5()
-                                    .mr_0p5(),
-                            )
-                            .child(
-                                IconButton::new("open-prompt-library", IconName::ArrowUpRightAlt)
-                                    .shape(ui::IconButtonShape::Square)
-                                    .icon_size(IconSize::XSmall)
-                                    .icon_color(Color::Ignored)
-                                    // TODO: Figure out a way to pass focus handle here so we can display the `OpenPromptLibrary`  keybinding
-                                    .tooltip(Tooltip::text("View User Rules"))
-                                    .on_click(move |_event, window, cx| {
-                                        window.dispatch_action(
-                                            Box::new(OpenPromptLibrary {
-                                                prompt_to_focus: first_default_user_rules_id,
-                                            }),
-                                            cx,
-                                        )
-                                    }),
+                                    .buffer_font(cx),
                             ),
                     )
-                },
+                    .child(
+                        IconButton::new("open-rule", IconName::ArrowUpRightAlt)
+                            .shape(ui::IconButtonShape::Square)
+                            .icon_size(IconSize::XSmall)
+                            .icon_color(Color::Ignored)
+                            .on_click(cx.listener(Self::handle_open_rules))
+                            .tooltip(Tooltip::text("View Rules")),
+                    ),
             )
-            .when_some(rules_file_text, |parent, rules_file_text| {
-                parent.child(
-                    h_flex()
-                        .w_full()
-                        .child(
-                            Icon::new(IconName::File)
-                                .size(IconSize::XSmall)
-                                .color(Color::Disabled),
-                        )
-                        .child(
-                            Label::new(rules_file_text)
-                                .size(LabelSize::XSmall)
-                                .color(Color::Muted)
-                                .buffer_font(cx)
-                                .ml_1p5()
-                                .mr_0p5(),
-                        )
-                        .child(
-                            IconButton::new("open-rule", IconName::ArrowUpRightAlt)
-                                .shape(ui::IconButtonShape::Square)
-                                .icon_size(IconSize::XSmall)
-                                .icon_color(Color::Ignored)
-                                .on_click(cx.listener(Self::handle_open_rules))
-                                .tooltip(Tooltip::text("View Rules")),
-                        ),
-                )
-            })
             .into_any()
     }
 

crates/agent/src/agent_diff.rs

@@ -922,7 +922,6 @@ mod tests {
             language::init(cx);
             Project::init_settings(cx);
             AssistantSettings::register(cx);
-            prompt_store::init(cx);
             thread_store::init(cx);
             workspace::init_settings(cx);
             ThemeSettings::register(cx);
@@ -952,8 +951,7 @@ mod tests {
                     cx,
                 )
             })
-            .await
-            .unwrap();
+            .await;
         let thread = thread_store.update(cx, |store, cx| store.create_thread(cx));
         let action_log = thread.read_with(cx, |thread, _| thread.action_log().clone());
 

crates/agent/src/assistant.rs

@@ -40,7 +40,7 @@ pub use crate::active_thread::ActiveThread;
 use crate::assistant_configuration::{AddContextServerModal, ManageProfilesModal};
 pub use crate::assistant_panel::{AssistantPanel, ConcreteAssistantPanelDelegate};
 pub use crate::inline_assistant::InlineAssistant;
-pub use crate::thread::{Message, Thread, ThreadEvent};
+pub use crate::thread::{Message, RequestKind, Thread, ThreadEvent};
 pub use crate::thread_store::ThreadStore;
 pub use agent_diff::{AgentDiff, AgentDiffToolbar};
 

crates/agent/src/assistant_configuration.rs

@@ -132,11 +132,7 @@ impl AssistantConfiguration {
             .cloned();
 
         v_flex()
-            .pt_3()
-            .pb_1()
             .gap_1p5()
-            .border_t_1()
-            .border_color(cx.theme().colors().border.opacity(0.6))
             .child(
                 h_flex()
                     .justify_between()
@@ -148,7 +144,7 @@ impl AssistantConfiguration {
                                     .size(IconSize::Small)
                                     .color(Color::Muted),
                             )
-                            .child(Label::new(provider_name.clone()).size(LabelSize::Large)),
+                            .child(Label::new(provider_name.clone())),
                     )
                     .when(provider.is_authenticated(cx), |parent| {
                         parent.child(
@@ -173,12 +169,20 @@ impl AssistantConfiguration {
                         )
                     }),
             )
-            .map(|parent| match configuration_view {
-                Some(configuration_view) => parent.child(configuration_view),
-                None => parent.child(div().child(Label::new(format!(
-                    "No configuration view for {provider_name}",
-                )))),
-            })
+            .child(
+                div()
+                    .p(DynamicSpacing::Base08.rems(cx))
+                    .bg(cx.theme().colors().editor_background)
+                    .border_1()
+                    .border_color(cx.theme().colors().border)
+                    .rounded_sm()
+                    .map(|parent| match configuration_view {
+                        Some(configuration_view) => parent.child(configuration_view),
+                        None => parent.child(div().child(Label::new(format!(
+                            "No configuration view for {provider_name}",
+                        )))),
+                    }),
+            )
     }
 
     fn render_provider_configuration_section(
@@ -195,7 +199,7 @@ impl AssistantConfiguration {
             .child(
                 v_flex()
                     .gap_0p5()
-                    .child(Headline::new("LLM Providers"))
+                    .child(Headline::new("LLM Providers").size(HeadlineSize::Small))
                     .child(
                         Label::new("Add at least one provider to use AI-powered features.")
                             .color(Color::Muted),
@@ -211,16 +215,21 @@ impl AssistantConfiguration {
     fn render_command_permission(&mut self, cx: &mut Context<Self>) -> impl IntoElement {
         let always_allow_tool_actions = AssistantSettings::get_global(cx).always_allow_tool_actions;
 
-        const HEADING: &str = "Allow running editing tools without asking for confirmation";
+        const HEADING: &str = "Allow running tools without asking for confirmation";
 
         v_flex()
             .p(DynamicSpacing::Base16.rems(cx))
             .pr(DynamicSpacing::Base20.rems(cx))
             .gap_2()
             .flex_1()
-            .child(Headline::new("General Settings"))
+            .child(Headline::new("General Settings").size(HeadlineSize::Small))
             .child(
                 h_flex()
+                    .p_2p5()
+                    .rounded_sm()
+                    .bg(cx.theme().colors().editor_background)
+                    .border_1()
+                    .border_color(cx.theme().colors().border)
                     .gap_4()
                     .justify_between()
                     .flex_wrap()
@@ -268,7 +277,10 @@ impl AssistantConfiguration {
             .child(
                 v_flex()
                     .gap_0p5()
-                    .child(Headline::new("Model Context Protocol (MCP) Servers"))
+                    .child(
+                        Headline::new("Model Context Protocol (MCP) Servers")
+                            .size(HeadlineSize::Small),
+                    )
                     .child(Label::new(SUBHEADING).color(Color::Muted)),
             )
             .children(context_servers.into_iter().map(|context_server| {
@@ -289,9 +301,9 @@ impl AssistantConfiguration {
                 v_flex()
                     .id(SharedString::from(context_server.id()))
                     .border_1()
-                    .rounded_md()
+                    .rounded_sm()
                     .border_color(cx.theme().colors().border)
-                    .bg(cx.theme().colors().background.opacity(0.25))
+                    .bg(cx.theme().colors().editor_background)
                     .child(
                         h_flex()
                             .p_1()
@@ -374,28 +386,34 @@ impl AssistantConfiguration {
                             return parent;
                         }
 
-                        parent.child(v_flex().py_1p5().px_1().gap_1().children(
-                            tools.into_iter().enumerate().map(|(ix, tool)| {
+                        parent.child(v_flex().children(tools.into_iter().enumerate().map(
+                            |(ix, tool)| {
                                 h_flex()
-                                    .id(("tool-item", ix))
-                                    .px_1()
+                                    .id("tool-item")
+                                    .pl_2()
+                                    .pr_1()
+                                    .py_1()
                                     .gap_2()
                                     .justify_between()
-                                    .hover(|style| style.bg(cx.theme().colors().element_hover))
-                                    .rounded_sm()
+                                    .when(ix < tool_count - 1, |element| {
+                                        element
+                                            .border_b_1()
+                                            .border_color(cx.theme().colors().border_variant)
+                                    })
                                     .child(
                                         Label::new(tool.name())
                                             .buffer_font(cx)
                                             .size(LabelSize::Small),
                                     )
                                     .child(
-                                        Icon::new(IconName::Info)
-                                            .size(IconSize::Small)
-                                            .color(Color::Ignored),
+                                        IconButton::new(("tool-description", ix), IconName::Info)
+                                            .shape(ui::IconButtonShape::Square)
+                                            .icon_size(IconSize::Small)
+                                            .icon_color(Color::Ignored)
+                                            .tooltip(Tooltip::text(tool.description())),
                                     )
-                                    .tooltip(Tooltip::text(tool.description()))
-                            }),
-                        ))
+                            },
+                        )))
                     })
             }))
             .child(
@@ -404,7 +422,7 @@ impl AssistantConfiguration {
                     .gap_2()
                     .child(
                         h_flex().w_full().child(
-                            Button::new("add-context-server", "Add Custom Server")
+                            Button::new("add-context-server", "Add MCPs Directly")
                                 .style(ButtonStyle::Filled)
                                 .layer(ElevationIndex::ModalSurface)
                                 .full_width()

crates/agent/src/assistant_configuration/add_context_server_modal.rs

@@ -2,7 +2,7 @@ use context_server::{ContextServerSettings, ServerCommand, ServerConfig};
 use gpui::{DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, WeakEntity, prelude::*};
 use serde_json::json;
 use settings::update_settings_file;
-use ui::{KeyBinding, Modal, ModalFooter, ModalHeader, Section, Tooltip, prelude::*};
+use ui::{Modal, ModalFooter, ModalHeader, Section, Tooltip, prelude::*};
 use ui_input::SingleLineInput;
 use workspace::{ModalView, Workspace};
 
@@ -34,9 +34,9 @@ impl AddContextServerModal {
         cx: &mut Context<Self>,
     ) -> Self {
         let name_editor =
-            cx.new(|cx| SingleLineInput::new(window, cx, "my-custom-server").label("Name"));
+            cx.new(|cx| SingleLineInput::new(window, cx, "Your server name").label("Name"));
         let command_editor = cx.new(|cx| {
-            SingleLineInput::new(window, cx, "Command").label("Command to run the MCP server")
+            SingleLineInput::new(window, cx, "Command").label("Command to run the context server")
         });
 
         Self {
@@ -46,7 +46,7 @@ impl AddContextServerModal {
         }
     }
 
-    fn confirm(&mut self, _: &menu::Confirm, cx: &mut Context<Self>) {
+    fn confirm(&mut self, cx: &mut Context<Self>) {
         let name = self
             .name_editor
             .read(cx)
@@ -96,7 +96,7 @@ impl AddContextServerModal {
         cx.emit(DismissEvent);
     }
 
-    fn cancel(&mut self, _: &menu::Cancel, cx: &mut Context<Self>) {
+    fn cancel(&mut self, cx: &mut Context<Self>) {
         cx.emit(DismissEvent);
     }
 }
@@ -112,68 +112,38 @@ impl Focusable for AddContextServerModal {
 impl EventEmitter<DismissEvent> for AddContextServerModal {}
 
 impl Render for AddContextServerModal {
-    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
         let is_name_empty = self.name_editor.read(cx).is_empty(cx);
         let is_command_empty = self.command_editor.read(cx).is_empty(cx);
 
-        let focus_handle = self.focus_handle(cx);
-
         div()
             .elevation_3(cx)
             .w(rems(34.))
             .key_context("AddContextServerModal")
-            .on_action(
-                cx.listener(|this, _: &menu::Cancel, _window, cx| this.cancel(&menu::Cancel, cx)),
-            )
-            .on_action(
-                cx.listener(|this, _: &menu::Confirm, _window, cx| {
-                    this.confirm(&menu::Confirm, cx)
-                }),
-            )
+            .on_action(cx.listener(|this, _: &menu::Cancel, _window, cx| this.cancel(cx)))
+            .on_action(cx.listener(|this, _: &menu::Confirm, _window, cx| this.confirm(cx)))
             .capture_any_mouse_down(cx.listener(|this, _, window, cx| {
                 this.focus_handle(cx).focus(window);
             }))
             .on_mouse_down_out(cx.listener(|_this, _, _, cx| cx.emit(DismissEvent)))
             .child(
                 Modal::new("add-context-server", None)
-                    .header(ModalHeader::new().headline("Add MCP Server"))
+                    .header(ModalHeader::new().headline("Add Context Server"))
                     .section(
-                        Section::new().child(
-                            v_flex()
-                                .gap_2()
-                                .child(self.name_editor.clone())
-                                .child(self.command_editor.clone()),
-                        ),
+                        Section::new()
+                            .child(self.name_editor.clone())
+                            .child(self.command_editor.clone()),
                     )
                     .footer(
                         ModalFooter::new()
                             .start_slot(
-                                Button::new("cancel", "Cancel")
-                                    .key_binding(
-                                        KeyBinding::for_action_in(
-                                            &menu::Cancel,
-                                            &focus_handle,
-                                            window,
-                                            cx,
-                                        )
-                                        .map(|kb| kb.size(rems_from_px(12.))),
-                                    )
-                                    .on_click(cx.listener(|this, _event, _window, cx| {
-                                        this.cancel(&menu::Cancel, cx)
-                                    })),
+                                Button::new("cancel", "Cancel").on_click(
+                                    cx.listener(|this, _event, _window, cx| this.cancel(cx)),
+                                ),
                             )
                             .end_slot(
                                 Button::new("add-server", "Add Server")
                                     .disabled(is_name_empty || is_command_empty)
-                                    .key_binding(
-                                        KeyBinding::for_action_in(
-                                            &menu::Confirm,
-                                            &focus_handle,
-                                            window,
-                                            cx,
-                                        )
-                                        .map(|kb| kb.size(rems_from_px(12.))),
-                                    )
                                     .map(|button| {
                                         if is_name_empty {
                                             button.tooltip(Tooltip::text("Name is required"))
@@ -183,9 +153,9 @@ impl Render for AddContextServerModal {
                                             button
                                         }
                                     })
-                                    .on_click(cx.listener(|this, _event, _window, cx| {
-                                        this.confirm(&menu::Confirm, cx)
-                                    })),
+                                    .on_click(
+                                        cx.listener(|this, _event, _window, cx| this.confirm(cx)),
+                                    ),
                             ),
                     ),
             )

crates/agent/src/assistant_model_selector.rs

@@ -1,7 +1,7 @@
 use assistant_settings::AssistantSettings;
 use fs::Fs;
 use gpui::{Entity, FocusHandle, SharedString};
-
+use language_model::LanguageModelRegistry;
 use language_model_selector::{
     LanguageModelSelector, LanguageModelSelectorPopoverMenu, ToggleModelSelector,
 };
@@ -9,12 +9,17 @@ use settings::update_settings_file;
 use std::sync::Arc;
 use ui::{ButtonLike, PopoverMenuHandle, Tooltip, prelude::*};
 
-pub use language_model_selector::ModelType;
+#[derive(Clone, Copy)]
+pub enum ModelType {
+    Default,
+    InlineAssistant,
+}
 
 pub struct AssistantModelSelector {
     selector: Entity<LanguageModelSelector>,
     menu_handle: PopoverMenuHandle<LanguageModelSelector>,
     focus_handle: FocusHandle,
+    model_type: ModelType,
 }
 
 impl AssistantModelSelector {
@@ -58,13 +63,13 @@ impl AssistantModelSelector {
                             }
                         }
                     },
-                    model_type,
                     window,
                     cx,
                 )
             }),
             menu_handle,
             focus_handle,
+            model_type,
         }
     }
 
@@ -77,7 +82,11 @@ impl Render for AssistantModelSelector {
     fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
         let focus_handle = self.focus_handle.clone();
 
-        let model = self.selector.read(cx).active_model(cx);
+        let model_registry = LanguageModelRegistry::read_global(cx);
+        let model = match self.model_type {
+            ModelType::Default => model_registry.default_model(),
+            ModelType::InlineAssistant => model_registry.inline_assistant_model(),
+        };
         let (model_name, model_icon) = match model {
             Some(model) => (model.model.name().0, Some(model.provider.icon())),
             _ => (SharedString::from("No model selected"), None),

crates/agent/src/assistant_panel.rs

@@ -25,7 +25,7 @@ use language_model::{LanguageModelProviderTosView, LanguageModelRegistry};
 use language_model_selector::ToggleModelSelector;
 use project::Project;
 use prompt_library::{PromptLibrary, open_prompt_library};
-use prompt_store::{PromptBuilder, PromptId};
+use prompt_store::PromptBuilder;
 use proto::Plan;
 use settings::{Settings, update_settings_file};
 use time::UtcOffset;
@@ -47,7 +47,7 @@ use crate::thread_history::{PastContext, PastThread, ThreadHistory};
 use crate::thread_store::ThreadStore;
 use crate::ui::UsageBanner;
 use crate::{
-    AddContextServer, AgentDiff, ExpandMessageEditor, InlineAssistant, NewTextThread, NewThread,
+    AgentDiff, ExpandMessageEditor, InlineAssistant, NewTextThread, NewThread,
     OpenActiveThreadAsMarkdown, OpenAgentDiff, OpenHistory, ThreadEvent, ToggleContextPicker,
 };
 
@@ -83,7 +83,7 @@ pub fn init(cx: &mut App) {
                     if let Some(panel) = workspace.panel::<AssistantPanel>(cx) {
                         workspace.focus_panel::<AssistantPanel>(window, cx);
                         panel.update(cx, |panel, cx| {
-                            panel.deploy_prompt_library(&OpenPromptLibrary::default(), window, cx)
+                            panel.deploy_prompt_library(&OpenPromptLibrary, window, cx)
                         });
                     }
                 })
@@ -213,7 +213,7 @@ impl AssistantPanel {
                     let project = workspace.project().clone();
                     ThreadStore::load(project, tools.clone(), prompt_builder.clone(), cx)
                 })?
-                .await?;
+                .await;
 
             let slash_commands = Arc::new(SlashCommandWorkingSet::default());
             let context_store = workspace
@@ -488,7 +488,7 @@ impl AssistantPanel {
 
     fn deploy_prompt_library(
         &mut self,
-        action: &OpenPromptLibrary,
+        _: &OpenPromptLibrary,
         _window: &mut Window,
         cx: &mut Context<Self>,
     ) {
@@ -502,7 +502,6 @@ impl AssistantPanel {
                     None,
                 ))
             }),
-            action.prompt_to_focus.map(|uuid| PromptId::User { uuid }),
             cx,
         )
         .detach_and_log_err(cx);
@@ -1120,19 +1119,17 @@ impl AssistantPanel {
                                                     "New Text Thread",
                                                     NewTextThread.boxed_clone(),
                                                 )
-                                                .action("Prompt Library", Box::new(OpenPromptLibrary::default()))
+                                                .action("Prompt Library", Box::new(OpenPromptLibrary))
                                                 .action("Settings", Box::new(OpenConfiguration))
                                                 .separator()
-                                                .header("MCPs")
                                                 .action(
-                                                    "View Server Extensions",
+                                                    "Install MCPs",
                                                     Box::new(zed_actions::Extensions {
                                                         category_filter: Some(
                                                             zed_actions::ExtensionCategoryFilter::ContextServers,
                                                         ),
                                                         }),
                                                 )
-                                                .action("Add Custom Server", Box::new(AddContextServer))
                                             },
                                         ))
                                     }),

crates/agent/src/buffer_codegen.rs

@@ -1,7 +1,7 @@
 use crate::context::attach_context_to_message;
 use crate::context_store::ContextStore;
 use crate::inline_prompt_editor::CodegenStatus;
-use anyhow::Result;
+use anyhow::{Context as _, Result};
 use client::telemetry::Telemetry;
 use collections::HashSet;
 use editor::{Anchor, AnchorRangeExt, MultiBuffer, MultiBufferSnapshot, ToOffset as _, ToPoint};
@@ -131,12 +131,7 @@ impl BufferCodegen {
         cx.notify();
     }
 
-    pub fn start(
-        &mut self,
-        primary_model: Arc<dyn LanguageModel>,
-        user_prompt: String,
-        cx: &mut Context<Self>,
-    ) -> Result<()> {
+    pub fn start(&mut self, user_prompt: String, cx: &mut Context<Self>) -> Result<()> {
         let alternative_models = LanguageModelRegistry::read_global(cx)
             .inline_alternative_models()
             .to_vec();
@@ -160,6 +155,11 @@ impl BufferCodegen {
             }));
         }
 
+        let primary_model = LanguageModelRegistry::read_global(cx)
+            .default_model()
+            .context("no active model")?
+            .model;
+
         for (model, alternative) in iter::once(primary_model)
             .chain(alternative_models)
             .zip(&self.alternatives)
@@ -425,8 +425,6 @@ impl CodegenAlternative {
         request_message.content.push(prompt.into());
 
         Ok(LanguageModelRequest {
-            thread_id: None,
-            prompt_id: None,
             tools: Vec::new(),
             stop: Vec::new(),
             temperature: None,

crates/agent/src/inline_assistant.rs

@@ -24,7 +24,6 @@ use gpui::{
     WeakEntity, Window, point,
 };
 use language::{Buffer, Point, Selection, TransactionId};
-use language_model::ConfiguredModel;
 use language_model::{LanguageModelRegistry, report_assistant_event};
 use multi_buffer::MultiBufferRow;
 use parking_lot::Mutex;
@@ -1222,15 +1221,9 @@ impl InlineAssistant {
             self.prompt_history.pop_front();
         }
 
-        let Some(ConfiguredModel { model, .. }) =
-            LanguageModelRegistry::read_global(cx).inline_assistant_model()
-        else {
-            return;
-        };
-
         assist
             .codegen
-            .update(cx, |codegen, cx| codegen.start(model, user_prompt, cx))
+            .update(cx, |codegen, cx| codegen.start(user_prompt, cx))
             .log_err();
     }
 

crates/agent/src/inline_prompt_editor.rs

@@ -1,4 +1,4 @@
-use crate::assistant_model_selector::AssistantModelSelector;
+use crate::assistant_model_selector::{AssistantModelSelector, ModelType};
 use crate::buffer_codegen::BufferCodegen;
 use crate::context_picker::ContextPicker;
 use crate::context_store::ContextStore;
@@ -20,7 +20,7 @@ use gpui::{
     Focusable, FontWeight, Subscription, TextStyle, WeakEntity, Window, anchored, deferred, point,
 };
 use language_model::{LanguageModel, LanguageModelRegistry};
-use language_model_selector::{ModelType, ToggleModelSelector};
+use language_model_selector::ToggleModelSelector;
 use parking_lot::Mutex;
 use settings::Settings;
 use std::cmp;

crates/agent/src/message_editor.rs

@@ -2,7 +2,7 @@ use std::collections::BTreeMap;
 use std::sync::Arc;
 
 use crate::assistant_model_selector::ModelType;
-use crate::context::{AssistantContext, format_context_as_string};
+use crate::context::format_context_as_string;
 use crate::tool_compatibility::{IncompatibleToolsState, IncompatibleToolsTooltip};
 use buffer_diff::BufferDiff;
 use collections::HashSet;
@@ -34,7 +34,7 @@ use crate::context_picker::{ContextPicker, ContextPickerCompletionProvider};
 use crate::context_store::{ContextStore, refresh_context_store_text};
 use crate::context_strip::{ContextStrip, ContextStripEvent, SuggestContextKind};
 use crate::profile_selector::ProfileSelector;
-use crate::thread::{Thread, TokenUsageRatio};
+use crate::thread::{RequestKind, Thread, TokenUsageRatio};
 use crate::thread_store::ThreadStore;
 use crate::{
     AgentDiff, Chat, ChatMode, ExpandMessageEditor, NewThread, OpenAgentDiff, RemoveAllContext,
@@ -234,7 +234,7 @@ impl MessageEditor {
         }
 
         self.set_editor_is_expanded(false, cx);
-        self.send_to_model(window, cx);
+        self.send_to_model(RequestKind::Chat, window, cx);
 
         cx.notify();
     }
@@ -249,7 +249,12 @@ impl MessageEditor {
             .is_some()
     }
 
-    fn send_to_model(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+    fn send_to_model(
+        &mut self,
+        request_kind: RequestKind,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
         let model_registry = LanguageModelRegistry::read_global(cx);
         let Some(ConfiguredModel { model, provider }) = model_registry.default_model() else {
             return;
@@ -288,21 +293,6 @@ impl MessageEditor {
                 })
                 .log_err();
 
-            context_store
-                .update(cx, |context_store, cx| {
-                    let excerpt_ids = context_store
-                        .context()
-                        .iter()
-                        .filter(|ctx| matches!(ctx, AssistantContext::Excerpt(_)))
-                        .map(|ctx| ctx.id())
-                        .collect::<Vec<_>>();
-
-                    for id in excerpt_ids {
-                        context_store.remove_context(id, cx);
-                    }
-                })
-                .log_err();
-
             if let Some(wait_for_summaries) = context_store
                 .update(cx, |context_store, cx| context_store.wait_for_summaries(cx))
                 .log_err()
@@ -325,8 +315,7 @@ impl MessageEditor {
             // Send to model after summaries are done
             thread
                 .update(cx, |thread, cx| {
-                    thread.advance_prompt_id();
-                    thread.send_to_model(model, cx);
+                    thread.send_to_model(model, request_kind, cx);
                 })
                 .log_err();
         })
@@ -340,7 +329,7 @@ impl MessageEditor {
 
         if cancelled {
             self.set_editor_is_expanded(false, cx);
-            self.send_to_model(window, cx);
+            self.send_to_model(RequestKind::Chat, window, cx);
         }
     }
 
@@ -1009,8 +998,6 @@ impl MessageEditor {
                 }
 
                 let request = language_model::LanguageModelRequest {
-                    thread_id: None,
-                    prompt_id: None,
                     messages: vec![LanguageModelRequestMessage {
                         role: language_model::Role::User,
                         content: vec![content.into()],

crates/agent/src/terminal_inline_assistant.rs

@@ -261,8 +261,6 @@ impl TerminalInlineAssistant {
         request_message.content.push(prompt.into());
 
         Ok(LanguageModelRequest {
-            thread_id: None,
-            prompt_id: None,
             messages: vec![request_message],
             tools: Vec::new(),
             stop: Vec::new(),

crates/agent/src/thread.rs

@@ -4,7 +4,7 @@ use std::ops::Range;
 use std::sync::Arc;
 use std::time::Instant;
 
-use anyhow::{Result, anyhow};
+use anyhow::{Context as _, Result, anyhow};
 use assistant_settings::AssistantSettings;
 use assistant_tool::{ActionLog, AnyToolCard, Tool, ToolWorkingSet};
 use chrono::{DateTime, Utc};
@@ -40,6 +40,13 @@ use crate::thread_store::{
 };
 use crate::tool_use::{PendingToolUse, ToolUse, ToolUseState, USING_TOOL_MARKER};
 
+#[derive(Debug, Clone, Copy)]
+pub enum RequestKind {
+    Chat,
+    /// Used when summarizing a thread.
+    Summarize,
+}
+
 #[derive(
     Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Serialize, Deserialize, JsonSchema,
 )]
@@ -63,24 +70,6 @@ impl From<&str> for ThreadId {
     }
 }
 
-/// The ID of the user prompt that initiated a request.
-///
-/// This equates to the user physically submitting a message to the model (e.g., by pressing the Enter key).
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Serialize, Deserialize)]
-pub struct PromptId(Arc<str>);
-
-impl PromptId {
-    pub fn new() -> Self {
-        Self(Uuid::new_v4().to_string().into())
-    }
-}
-
-impl std::fmt::Display for PromptId {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
-
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, Serialize, Deserialize)]
 pub struct MessageId(pub(crate) usize);
 
@@ -106,21 +95,12 @@ impl Message {
         self.segments.iter().all(|segment| segment.should_display())
     }
 
-    pub fn push_thinking(&mut self, text: &str, signature: Option<String>) {
-        if let Some(MessageSegment::Thinking {
-            text: segment,
-            signature: current_signature,
-        }) = self.segments.last_mut()
-        {
-            if let Some(signature) = signature {
-                *current_signature = Some(signature);
-            }
+    pub fn push_thinking(&mut self, text: &str) {
+        if let Some(MessageSegment::Thinking(segment)) = self.segments.last_mut() {
             segment.push_str(text);
         } else {
-            self.segments.push(MessageSegment::Thinking {
-                text: text.to_string(),
-                signature,
-            });
+            self.segments
+                .push(MessageSegment::Thinking(text.to_string()));
         }
     }
 
@@ -142,12 +122,11 @@ impl Message {
         for segment in &self.segments {
             match segment {
                 MessageSegment::Text(text) => result.push_str(text),
-                MessageSegment::Thinking { text, .. } => {
-                    result.push_str("<think>\n");
+                MessageSegment::Thinking(text) => {
+                    result.push_str("<think>");
                     result.push_str(text);
-                    result.push_str("\n</think>");
+                    result.push_str("</think>");
                 }
-                MessageSegment::RedactedThinking(_) => {}
             }
         }
 
@@ -158,22 +137,24 @@ impl Message {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum MessageSegment {
     Text(String),
-    Thinking {
-        text: String,
-        signature: Option<String>,
-    },
-    RedactedThinking(Vec<u8>),
+    Thinking(String),
 }
 
 impl MessageSegment {
+    pub fn text_mut(&mut self) -> &mut String {
+        match self {
+            Self::Text(text) => text,
+            Self::Thinking(text) => text,
+        }
+    }
+
     pub fn should_display(&self) -> bool {
         // We add USING_TOOL_MARKER when making a request that includes tool uses
         // without non-whitespace text around them, and this can cause the model
         // to mimic the pattern, so we consider those segments not displayable.
         match self {
             Self::Text(text) => text.is_empty() || text.trim() == USING_TOOL_MARKER,
-            Self::Thinking { text, .. } => text.is_empty() || text.trim() == USING_TOOL_MARKER,
-            Self::RedactedThinking(_) => false,
+            Self::Thinking(text) => text.is_empty() || text.trim() == USING_TOOL_MARKER,
         }
     }
 }
@@ -293,7 +274,6 @@ pub struct Thread {
     detailed_summary_state: DetailedSummaryState,
     messages: Vec<Message>,
     next_message_id: MessageId,
-    last_prompt_id: PromptId,
     context: BTreeMap<ContextId, AssistantContext>,
     context_by_message: HashMap<MessageId, Vec<ContextId>>,
     project_context: SharedProjectContext,
@@ -343,7 +323,6 @@ impl Thread {
             detailed_summary_state: DetailedSummaryState::NotGenerated,
             messages: Vec::new(),
             next_message_id: MessageId(0),
-            last_prompt_id: PromptId::new(),
             context: BTreeMap::default(),
             context_by_message: HashMap::default(),
             project_context: system_prompt,
@@ -409,11 +388,8 @@ impl Thread {
                         .into_iter()
                         .map(|segment| match segment {
                             SerializedMessageSegment::Text { text } => MessageSegment::Text(text),
-                            SerializedMessageSegment::Thinking { text, signature } => {
-                                MessageSegment::Thinking { text, signature }
-                            }
-                            SerializedMessageSegment::RedactedThinking { data } => {
-                                MessageSegment::RedactedThinking(data)
+                            SerializedMessageSegment::Thinking { text } => {
+                                MessageSegment::Thinking(text)
                             }
                         })
                         .collect(),
@@ -421,7 +397,6 @@ impl Thread {
                 })
                 .collect(),
             next_message_id,
-            last_prompt_id: PromptId::new(),
             context: BTreeMap::default(),
             context_by_message: HashMap::default(),
             project_context,
@@ -470,10 +445,6 @@ impl Thread {
         self.updated_at = Utc::now();
     }
 
-    pub fn advance_prompt_id(&mut self) {
-        self.last_prompt_id = PromptId::new();
-    }
-
     pub fn summary(&self) -> Option<SharedString> {
         self.summary.clone()
     }
@@ -866,10 +837,9 @@ impl Thread {
             for segment in &message.segments {
                 match segment {
                     MessageSegment::Text(content) => text.push_str(content),
-                    MessageSegment::Thinking { text: content, .. } => {
+                    MessageSegment::Thinking(content) => {
                         text.push_str(&format!("<think>{}</think>", content))
                     }
-                    MessageSegment::RedactedThinking(_) => {}
                 }
             }
             text.push('\n');
@@ -899,16 +869,8 @@ impl Thread {
                                 MessageSegment::Text(text) => {
                                     SerializedMessageSegment::Text { text: text.clone() }
                                 }
-                                MessageSegment::Thinking { text, signature } => {
-                                    SerializedMessageSegment::Thinking {
-                                        text: text.clone(),
-                                        signature: signature.clone(),
-                                    }
-                                }
-                                MessageSegment::RedactedThinking(data) => {
-                                    SerializedMessageSegment::RedactedThinking {
-                                        data: data.clone(),
-                                    }
+                                MessageSegment::Thinking(text) => {
+                                    SerializedMessageSegment::Thinking { text: text.clone() }
                                 }
                             })
                             .collect(),
@@ -942,8 +904,13 @@ impl Thread {
         })
     }
 
-    pub fn send_to_model(&mut self, model: Arc<dyn LanguageModel>, cx: &mut Context<Self>) {
-        let mut request = self.to_completion_request(cx);
+    pub fn send_to_model(
+        &mut self,
+        model: Arc<dyn LanguageModel>,
+        request_kind: RequestKind,
+        cx: &mut Context<Self>,
+    ) {
+        let mut request = self.to_completion_request(request_kind, cx);
         if model.supports_tools() {
             request.tools = {
                 let mut tools = Vec::new();
@@ -982,10 +949,12 @@ impl Thread {
         false
     }
 
-    pub fn to_completion_request(&self, cx: &mut Context<Self>) -> LanguageModelRequest {
+    pub fn to_completion_request(
+        &self,
+        request_kind: RequestKind,
+        cx: &App,
+    ) -> LanguageModelRequest {
         let mut request = LanguageModelRequest {
-            thread_id: Some(self.id.to_string()),
-            prompt_id: Some(self.last_prompt_id.to_string()),
             messages: vec![],
             tools: Vec::new(),
             stop: Vec::new(),
@@ -993,33 +962,20 @@ impl Thread {
         };
 
         if let Some(project_context) = self.project_context.borrow().as_ref() {
-            match self
+            if let Some(system_prompt) = self
                 .prompt_builder
                 .generate_assistant_system_prompt(project_context)
+                .context("failed to generate assistant system prompt")
+                .log_err()
             {
-                Err(err) => {
-                    let message = format!("{err:?}").into();
-                    log::error!("{message}");
-                    cx.emit(ThreadEvent::ShowError(ThreadError::Message {
-                        header: "Error generating system prompt".into(),
-                        message,
-                    }));
-                }
-                Ok(system_prompt) => {
-                    request.messages.push(LanguageModelRequestMessage {
-                        role: Role::System,
-                        content: vec![MessageContent::Text(system_prompt)],
-                        cache: true,
-                    });
-                }
+                request.messages.push(LanguageModelRequestMessage {
+                    role: Role::System,
+                    content: vec![MessageContent::Text(system_prompt)],
+                    cache: true,
+                });
             }
         } else {
-            let message = "Context for system prompt unexpectedly not ready.".into();
-            log::error!("{message}");
-            cx.emit(ThreadEvent::ShowError(ThreadError::Message {
-                header: "Error generating system prompt".into(),
-                message,
-            }));
+            log::error!("project_context not set.")
         }
 
         for message in &self.messages {
@@ -1029,42 +985,34 @@ impl Thread {
                 cache: false,
             };
 
-            self.tool_use
-                .attach_tool_results(message.id, &mut request_message);
+            match request_kind {
+                RequestKind::Chat => {
+                    self.tool_use
+                        .attach_tool_results(message.id, &mut request_message);
+                }
+                RequestKind::Summarize => {
+                    // We don't care about tool use during summarization.
+                    if self.tool_use.message_has_tool_results(message.id) {
+                        continue;
+                    }
+                }
+            }
 
-            if !message.context.is_empty() {
+            if !message.segments.is_empty() {
                 request_message
                     .content
-                    .push(MessageContent::Text(message.context.to_string()));
+                    .push(MessageContent::Text(message.to_string()));
             }
 
-            for segment in &message.segments {
-                match segment {
-                    MessageSegment::Text(text) => {
-                        if !text.is_empty() {
-                            request_message
-                                .content
-                                .push(MessageContent::Text(text.into()));
-                        }
-                    }
-                    MessageSegment::Thinking { text, signature } => {
-                        if !text.is_empty() {
-                            request_message.content.push(MessageContent::Thinking {
-                                text: text.into(),
-                                signature: signature.clone(),
-                            });
-                        }
-                    }
-                    MessageSegment::RedactedThinking(data) => {
-                        request_message
-                            .content
-                            .push(MessageContent::RedactedThinking(data.clone()));
-                    }
-                };
-            }
-
-            self.tool_use
-                .attach_tool_uses(message.id, &mut request_message);
+            match request_kind {
+                RequestKind::Chat => {
+                    self.tool_use
+                        .attach_tool_uses(message.id, &mut request_message);
+                }
+                RequestKind::Summarize => {
+                    // We don't care about tool use during summarization.
+                }
+            };
 
             request.messages.push(request_message);
         }
@@ -1079,54 +1027,6 @@ impl Thread {
         request
     }
 
-    fn to_summarize_request(&self, added_user_message: String) -> LanguageModelRequest {
-        let mut request = LanguageModelRequest {
-            thread_id: None,
-            prompt_id: None,
-            messages: vec![],
-            tools: Vec::new(),
-            stop: Vec::new(),
-            temperature: None,
-        };
-
-        for message in &self.messages {
-            let mut request_message = LanguageModelRequestMessage {
-                role: message.role,
-                content: Vec::new(),
-                cache: false,
-            };
-
-            // Skip tool results during summarization.
-            if self.tool_use.message_has_tool_results(message.id) {
-                continue;
-            }
-
-            for segment in &message.segments {
-                match segment {
-                    MessageSegment::Text(text) => request_message
-                        .content
-                        .push(MessageContent::Text(text.clone())),
-                    MessageSegment::Thinking { .. } => {}
-                    MessageSegment::RedactedThinking(_) => {}
-                }
-            }
-
-            if request_message.content.is_empty() {
-                continue;
-            }
-
-            request.messages.push(request_message);
-        }
-
-        request.messages.push(LanguageModelRequestMessage {
-            role: Role::User,
-            content: vec![MessageContent::Text(added_user_message)],
-            cache: false,
-        });
-
-        request
-    }
-
     fn attached_tracked_files_state(
         &self,
         messages: &mut Vec<LanguageModelRequestMessage>,
@@ -1179,7 +1079,7 @@ impl Thread {
         } else {
             None
         };
-        let prompt_id = self.last_prompt_id.clone();
+
         let task = cx.spawn(async move |thread, cx| {
             let stream_completion_future = model.stream_completion_with_usage(request, &cx);
             let initial_token_usage =
@@ -1247,13 +1147,10 @@ impl Thread {
                                     };
                                 }
                             }
-                            LanguageModelCompletionEvent::Thinking {
-                                text: chunk,
-                                signature,
-                            } => {
+                            LanguageModelCompletionEvent::Thinking(chunk) => {
                                 if let Some(last_message) = thread.messages.last_mut() {
                                     if last_message.role == Role::Assistant {
-                                        last_message.push_thinking(&chunk, signature);
+                                        last_message.push_thinking(&chunk);
                                         cx.emit(ThreadEvent::StreamedAssistantThinking(
                                             last_message.id,
                                             chunk,
@@ -1266,10 +1163,7 @@ impl Thread {
                                         // will result in duplicating the text of the chunk in the rendered Markdown.
                                         thread.insert_message(
                                             Role::Assistant,
-                                            vec![MessageSegment::Thinking {
-                                                text: chunk.to_string(),
-                                                signature,
-                                            }],
+                                            vec![MessageSegment::Thinking(chunk.to_string())],
                                             cx,
                                         );
                                     };
@@ -1308,12 +1202,7 @@ impl Thread {
                         .pending_completions
                         .retain(|completion| completion.id != pending_completion_id);
 
-                    // If there is a response without tool use, summarize the message. Otherwise,
-                    // allow two tool uses before summarizing.
-                    if thread.summary.is_none()
-                        && thread.messages.len() >= 2
-                        && (!thread.has_pending_tool_uses() || thread.messages.len() >= 6)
-                    {
+                    if thread.summary.is_none() && thread.messages.len() >= 2 {
                         thread.summarize(cx);
                     }
                 })?;
@@ -1395,7 +1284,6 @@ impl Thread {
                         telemetry::event!(
                             "Assistant Thread Completion",
                             thread_id = thread.id().to_string(),
-                            prompt_id = prompt_id,
                             model = model.telemetry_id(),
                             model_provider = model.provider_id().to_string(),
                             input_tokens = usage.input_tokens,
@@ -1423,12 +1311,18 @@ impl Thread {
             return;
         }
 
-        let added_user_message = "Generate a concise 3-7 word title for this conversation, omitting punctuation. \
-            Go straight to the title, without any preamble and prefix like `Here's a concise suggestion:...` or `Title:`. \
-            If the conversation is about a specific subject, include it in the title. \
-            Be descriptive. DO NOT speak in the first person.";
-
-        let request = self.to_summarize_request(added_user_message.into());
+        let mut request = self.to_completion_request(RequestKind::Summarize, cx);
+        request.messages.push(LanguageModelRequestMessage {
+            role: Role::User,
+            content: vec![
+                "Generate a concise 3-7 word title for this conversation, omitting punctuation. \
+                 Go straight to the title, without any preamble and prefix like `Here's a concise suggestion:...` or `Title:`. \
+                 If the conversation is about a specific subject, include it in the title. \
+                 Be descriptive. DO NOT speak in the first person."
+                    .into(),
+            ],
+            cache: false,
+        });
 
         self.pending_summary = cx.spawn(async move |this, cx| {
             async move {
@@ -1490,14 +1384,21 @@ impl Thread {
             return None;
         }
 
-        let added_user_message = "Generate a detailed summary of this conversation. Include:\n\
-             1. A brief overview of what was discussed\n\
-             2. Key facts or information discovered\n\
-             3. Outcomes or conclusions reached\n\
-             4. Any action items or next steps if any\n\
-             Format it in Markdown with headings and bullet points.";
+        let mut request = self.to_completion_request(RequestKind::Summarize, cx);
 
-        let request = self.to_summarize_request(added_user_message.into());
+        request.messages.push(LanguageModelRequestMessage {
+            role: Role::User,
+            content: vec![
+                "Generate a detailed summary of this conversation. Include:\n\
+                1. A brief overview of what was discussed\n\
+                2. Key facts or information discovered\n\
+                3. Outcomes or conclusions reached\n\
+                4. Any action items or next steps if any\n\
+                Format it in Markdown with headings and bullet points."
+                    .into(),
+            ],
+            cache: false,
+        });
 
         let task = cx.spawn(async move |thread, cx| {
             let stream = model.stream_completion_text(request, &cx);
@@ -1545,7 +1446,7 @@ impl Thread {
 
     pub fn use_pending_tools(&mut self, cx: &mut Context<Self>) -> Vec<PendingToolUse> {
         self.auto_capture_telemetry(cx);
-        let request = self.to_completion_request(cx);
+        let request = self.to_completion_request(RequestKind::Chat, cx);
         let messages = Arc::new(request.messages);
         let pending_tool_uses = self
             .tool_use
@@ -1657,7 +1558,7 @@ impl Thread {
             if let Some(ConfiguredModel { model, .. }) = model_registry.default_model() {
                 self.attach_tool_results(cx);
                 if !canceled {
-                    self.send_to_model(model, cx);
+                    self.send_to_model(model, RequestKind::Chat, cx);
                 }
             }
         }
@@ -1670,8 +1571,6 @@ impl Thread {
 
     /// Insert an empty message to be populated with tool results upon send.
     pub fn attach_tool_results(&mut self, cx: &mut Context<Self>) {
-        // Tool results are assumed to be waiting on the next message id, so they will populate
-        // this empty message before sending to model. Would prefer this to be more straightforward.
         self.insert_message(Role::User, vec![], cx);
         self.auto_capture_telemetry(cx);
     }
@@ -1952,10 +1851,9 @@ impl Thread {
             for segment in &message.segments {
                 match segment {
                     MessageSegment::Text(text) => writeln!(markdown, "{}\n", text)?,
-                    MessageSegment::Thinking { text, .. } => {
-                        writeln!(markdown, "<think>\n{}\n</think>\n", text)?
+                    MessageSegment::Thinking(text) => {
+                        writeln!(markdown, "<think>{}</think>\n", text)?
                     }
-                    MessageSegment::RedactedThinking(_) => {}
                 }
             }
 
@@ -2282,7 +2180,9 @@ fn main() {{
         assert_eq!(message.context, expected_context);
 
         // Check message in request
-        let request = thread.update(cx, |thread, cx| thread.to_completion_request(cx));
+        let request = thread.read_with(cx, |thread, cx| {
+            thread.to_completion_request(RequestKind::Chat, cx)
+        });
 
         assert_eq!(request.messages.len(), 2);
         let expected_full_message = format!("{}Please explain this code", expected_context);
@@ -2372,7 +2272,9 @@ fn main() {{
         assert!(message3.context.contains("file3.rs"));
 
         // Check entire request to make sure all contexts are properly included
-        let request = thread.update(cx, |thread, cx| thread.to_completion_request(cx));
+        let request = thread.read_with(cx, |thread, cx| {
+            thread.to_completion_request(RequestKind::Chat, cx)
+        });
 
         // The request should contain all 3 messages
         assert_eq!(request.messages.len(), 4);
@@ -2422,7 +2324,9 @@ fn main() {{
         assert_eq!(message.context, "");
 
         // Check message in request
-        let request = thread.update(cx, |thread, cx| thread.to_completion_request(cx));
+        let request = thread.read_with(cx, |thread, cx| {
+            thread.to_completion_request(RequestKind::Chat, cx)
+        });
 
         assert_eq!(request.messages.len(), 2);
         assert_eq!(
@@ -2440,7 +2344,9 @@ fn main() {{
         assert_eq!(message2.context, "");
 
         // Check that both messages appear in the request
-        let request = thread.update(cx, |thread, cx| thread.to_completion_request(cx));
+        let request = thread.read_with(cx, |thread, cx| {
+            thread.to_completion_request(RequestKind::Chat, cx)
+        });
 
         assert_eq!(request.messages.len(), 3);
         assert_eq!(
@@ -2480,7 +2386,9 @@ fn main() {{
         });
 
         // Create a request and check that it doesn't have a stale buffer warning yet
-        let initial_request = thread.update(cx, |thread, cx| thread.to_completion_request(cx));
+        let initial_request = thread.read_with(cx, |thread, cx| {
+            thread.to_completion_request(RequestKind::Chat, cx)
+        });
 
         // Make sure we don't have a stale file warning yet
         let has_stale_warning = initial_request.messages.iter().any(|msg| {
@@ -2508,7 +2416,9 @@ fn main() {{
         });
 
         // Create a new request and check for the stale buffer warning
-        let new_request = thread.update(cx, |thread, cx| thread.to_completion_request(cx));
+        let new_request = thread.read_with(cx, |thread, cx| {
+            thread.to_completion_request(RequestKind::Chat, cx)
+        });
 
         // We should have a stale file warning as the last message
         let last_message = new_request
@@ -2535,7 +2445,6 @@ fn main() {{
             language::init(cx);
             Project::init_settings(cx);
             AssistantSettings::register(cx);
-            prompt_store::init(cx);
             thread_store::init(cx);
             workspace::init_settings(cx);
             ThemeSettings::register(cx);
@@ -2575,8 +2484,7 @@ fn main() {{
                     cx,
                 )
             })
-            .await
-            .unwrap();
+            .await;
 
         let thread = thread_store.update(cx, |store, cx| store.create_thread(cx));
         let context_store = cx.new(|_cx| ContextStore::new(project.downgrade(), None));

crates/agent/src/thread_store.rs

@@ -12,9 +12,8 @@ use collections::HashMap;
 use context_server::manager::ContextServerManager;
 use context_server::{ContextServerFactoryRegistry, ContextServerTool};
 use fs::Fs;
-use futures::channel::{mpsc, oneshot};
+use futures::FutureExt as _;
 use futures::future::{self, BoxFuture, Shared};
-use futures::{FutureExt as _, StreamExt as _};
 use gpui::{
     App, BackgroundExecutor, Context, Entity, EventEmitter, Global, ReadGlobal, SharedString,
     Subscription, Task, prelude::*,
@@ -23,10 +22,7 @@ use heed::Database;
 use heed::types::SerdeBincode;
 use language_model::{LanguageModelToolUseId, Role, TokenUsage};
 use project::{Project, Worktree};
-use prompt_store::{
-    DefaultUserRulesContext, ProjectContext, PromptBuilder, PromptId, PromptStore,
-    PromptsUpdatedEvent, RulesFileContext, WorktreeContext,
-};
+use prompt_store::{ProjectContext, PromptBuilder, RulesFileContext, WorktreeContext};
 use serde::{Deserialize, Serialize};
 use settings::{Settings as _, SettingsStore};
 use util::ResultExt as _;
@@ -66,8 +62,6 @@ pub struct ThreadStore {
     context_server_tool_ids: HashMap<Arc<str>, Vec<ToolId>>,
     threads: Vec<SerializedThreadMetadata>,
     project_context: SharedProjectContext,
-    reload_system_prompt_tx: mpsc::Sender<()>,
-    _reload_system_prompt_task: Task<()>,
     _subscriptions: Vec<Subscription>,
 }
 
@@ -83,22 +77,12 @@ impl ThreadStore {
         tools: Entity<ToolWorkingSet>,
         prompt_builder: Arc<PromptBuilder>,
         cx: &mut App,
-    ) -> Task<Result<Entity<Self>>> {
-        let prompt_store = PromptStore::global(cx);
-        cx.spawn(async move |cx| {
-            let prompt_store = prompt_store.await.ok();
-            let (thread_store, ready_rx) = cx.update(|cx| {
-                let mut option_ready_rx = None;
-                let thread_store = cx.new(|cx| {
-                    let (thread_store, ready_rx) =
-                        Self::new(project, tools, prompt_builder, prompt_store, cx);
-                    option_ready_rx = Some(ready_rx);
-                    thread_store
-                });
-                (thread_store, option_ready_rx.take().unwrap())
-            })?;
-            ready_rx.await?;
-            Ok(thread_store)
+    ) -> Task<Entity<Self>> {
+        let thread_store = cx.new(|cx| Self::new(project, tools, prompt_builder, cx));
+        let reload = thread_store.update(cx, |store, cx| store.reload_system_prompt(cx));
+        cx.foreground_executor().spawn(async move {
+            reload.await;
+            thread_store
         })
     }
 
@@ -106,53 +90,17 @@ impl ThreadStore {
         project: Entity<Project>,
         tools: Entity<ToolWorkingSet>,
         prompt_builder: Arc<PromptBuilder>,
-        prompt_store: Option<Entity<PromptStore>>,
         cx: &mut Context<Self>,
-    ) -> (Self, oneshot::Receiver<()>) {
+    ) -> Self {
         let context_server_factory_registry = ContextServerFactoryRegistry::default_global(cx);
         let context_server_manager = cx.new(|cx| {
             ContextServerManager::new(context_server_factory_registry, project.clone(), cx)
         });
-
-        let mut subscriptions = vec![
+        let settings_subscription =
             cx.observe_global::<SettingsStore>(move |this: &mut Self, cx| {
                 this.load_default_profile(cx);
-            }),
-            cx.subscribe(&project, Self::handle_project_event),
-        ];
-
-        if let Some(prompt_store) = prompt_store.as_ref() {
-            subscriptions.push(cx.subscribe(
-                prompt_store,
-                |this, _prompt_store, PromptsUpdatedEvent, _cx| {
-                    this.enqueue_system_prompt_reload();
-                },
-            ))
-        }
-
-        // This channel and task prevent concurrent and redundant loading of the system prompt.
-        let (reload_system_prompt_tx, mut reload_system_prompt_rx) = mpsc::channel(1);
-        let (ready_tx, ready_rx) = oneshot::channel();
-        let mut ready_tx = Some(ready_tx);
-        let reload_system_prompt_task = cx.spawn({
-            async move |thread_store, cx| {
-                loop {
-                    let Some(reload_task) = thread_store
-                        .update(cx, |thread_store, cx| {
-                            thread_store.reload_system_prompt(prompt_store.clone(), cx)
-                        })
-                        .ok()
-                    else {
-                        return;
-                    };
-                    reload_task.await;
-                    if let Some(ready_tx) = ready_tx.take() {
-                        ready_tx.send(()).ok();
-                    }
-                    reload_system_prompt_rx.next().await;
-                }
-            }
-        });
+            });
+        let project_subscription = cx.subscribe(&project, Self::handle_project_event);
 
         let this = Self {
             project,
@@ -162,25 +110,23 @@ impl ThreadStore {
             context_server_tool_ids: HashMap::default(),
             threads: Vec::new(),
             project_context: SharedProjectContext::default(),
-            reload_system_prompt_tx,
-            _reload_system_prompt_task: reload_system_prompt_task,
-            _subscriptions: subscriptions,
+            _subscriptions: vec![settings_subscription, project_subscription],
         };
         this.load_default_profile(cx);
         this.register_context_server_handlers(cx);
         this.reload(cx).detach_and_log_err(cx);
-        (this, ready_rx)
+        this
     }
 
     fn handle_project_event(
         &mut self,
         _project: Entity<Project>,
         event: &project::Event,
-        _cx: &mut Context<Self>,
+        cx: &mut Context<Self>,
     ) {
         match event {
             project::Event::WorktreeAdded(_) | project::Event::WorktreeRemoved(_) => {
-                self.enqueue_system_prompt_reload();
+                self.reload_system_prompt(cx).detach();
             }
             project::Event::WorktreeUpdatedEntries(_, items) => {
                 if items.iter().any(|(path, _, _)| {
@@ -188,25 +134,16 @@ impl ThreadStore {
                         .iter()
                         .any(|name| path.as_ref() == Path::new(name))
                 }) {
-                    self.enqueue_system_prompt_reload();
+                    self.reload_system_prompt(cx).detach();
                 }
             }
             _ => {}
         }
     }
 
-    fn enqueue_system_prompt_reload(&mut self) {
-        self.reload_system_prompt_tx.try_send(()).ok();
-    }
-
-    // Note that this should only be called from `reload_system_prompt_task`.
-    fn reload_system_prompt(
-        &self,
-        prompt_store: Option<Entity<PromptStore>>,
-        cx: &mut Context<Self>,
-    ) -> Task<()> {
+    pub fn reload_system_prompt(&self, cx: &mut Context<Self>) -> Task<()> {
         let project = self.project.read(cx);
-        let worktree_tasks = project
+        let tasks = project
             .visible_worktrees(cx)
             .map(|worktree| {
                 Self::load_worktree_info_for_system_prompt(
@@ -216,23 +153,10 @@ impl ThreadStore {
                 )
             })
             .collect::<Vec<_>>();
-        let default_user_rules_task = match prompt_store {
-            None => Task::ready(vec![]),
-            Some(prompt_store) => prompt_store.read_with(cx, |prompt_store, cx| {
-                let prompts = prompt_store.default_prompt_metadata();
-                let load_tasks = prompts.into_iter().map(|prompt_metadata| {
-                    let contents = prompt_store.load(prompt_metadata.id, cx);
-                    async move { (contents.await, prompt_metadata) }
-                });
-                cx.background_spawn(future::join_all(load_tasks))
-            }),
-        };
 
         cx.spawn(async move |this, cx| {
-            let (worktrees, default_user_rules) =
-                future::join(future::join_all(worktree_tasks), default_user_rules_task).await;
-
-            let worktrees = worktrees
+            let results = futures::future::join_all(tasks).await;
+            let worktrees = results
                 .into_iter()
                 .map(|(worktree, rules_error)| {
                     if let Some(rules_error) = rules_error {
@@ -241,33 +165,8 @@ impl ThreadStore {
                     worktree
                 })
                 .collect::<Vec<_>>();
-
-            let default_user_rules = default_user_rules
-                .into_iter()
-                .flat_map(|(contents, prompt_metadata)| match contents {
-                    Ok(contents) => Some(DefaultUserRulesContext {
-                        uuid: match prompt_metadata.id {
-                            PromptId::User { uuid } => uuid,
-                            PromptId::EditWorkflow => return None,
-                        },
-                        title: prompt_metadata.title.map(|title| title.to_string()),
-                        contents,
-                    }),
-                    Err(err) => {
-                        this.update(cx, |_, cx| {
-                            cx.emit(RulesLoadingError {
-                                message: format!("{err:?}").into(),
-                            });
-                        })
-                        .ok();
-                        None
-                    }
-                })
-                .collect::<Vec<_>>();
-
             this.update(cx, |this, _cx| {
-                *this.project_context.0.borrow_mut() =
-                    Some(ProjectContext::new(worktrees, default_user_rules));
+                *this.project_context.0.borrow_mut() = Some(ProjectContext::new(worktrees));
             })
             .ok();
         })
@@ -279,12 +178,14 @@ impl ThreadStore {
         cx: &App,
     ) -> Task<(WorktreeContext, Option<RulesLoadingError>)> {
         let root_name = worktree.root_name().into();
+        let abs_path = worktree.abs_path();
 
         let rules_task = Self::load_worktree_rules_file(fs, worktree, cx);
         let Some(rules_task) = rules_task else {
             return Task::ready((
                 WorktreeContext {
                     root_name,
+                    abs_path,
                     rules_file: None,
                 },
                 None,
@@ -303,6 +204,7 @@ impl ThreadStore {
             };
             let worktree_info = WorktreeContext {
                 root_name,
+                abs_path,
                 rules_file,
             };
             (worktree_info, rules_file_error)
@@ -660,18 +562,9 @@ pub struct SerializedMessage {
 #[serde(tag = "type")]
 pub enum SerializedMessageSegment {
     #[serde(rename = "text")]
-    Text {
-        text: String,
-    },
+    Text { text: String },
     #[serde(rename = "thinking")]
-    Thinking {
-        text: String,
-        #[serde(skip_serializing_if = "Option::is_none")]
-        signature: Option<String>,
-    },
-    RedactedThinking {
-        data: Vec<u8>,
-    },
+    Thinking { text: String },
 }
 
 #[derive(Debug, Serialize, Deserialize)]

crates/agent/src/ui/agent_notification.rs

@@ -59,7 +59,6 @@ impl AgentNotification {
             app_id: Some(app_id.to_owned()),
             window_min_size: None,
             window_decorations: Some(WindowDecorations::Client),
-            ..Default::default()
         }
     }
 }

crates/anthropic/src/anthropic.rs

@@ -74,10 +74,6 @@ pub enum Model {
 }
 
 impl Model {
-    pub fn default_fast() -> Self {
-        Self::Claude3_5Haiku
-    }
-
     pub fn from_id(id: &str) -> Result<Self> {
         if id.starts_with("claude-3-5-sonnet") {
             Ok(Self::Claude3_5Sonnet)
@@ -511,15 +507,6 @@ pub enum RequestContent {
         #[serde(skip_serializing_if = "Option::is_none")]
         cache_control: Option<CacheControl>,
     },
-    #[serde(rename = "thinking")]
-    Thinking {
-        thinking: String,
-        signature: String,
-        #[serde(skip_serializing_if = "Option::is_none")]
-        cache_control: Option<CacheControl>,
-    },
-    #[serde(rename = "redacted_thinking")]
-    RedactedThinking { data: String },
     #[serde(rename = "image")]
     Image {
         source: ImageSource,

crates/assistant/src/assistant.rs

@@ -8,7 +8,7 @@ mod terminal_inline_assistant;
 
 use std::sync::Arc;
 
-use assistant_settings::{AssistantSettings, LanguageModelSelection};
+use assistant_settings::AssistantSettings;
 use assistant_slash_command::SlashCommandRegistry;
 use client::Client;
 use command_palette_hooks::CommandPaletteFilter;
@@ -161,38 +161,71 @@ fn init_language_model_settings(cx: &mut App) {
 
 fn update_active_language_model_from_settings(cx: &mut App) {
     let settings = AssistantSettings::get_global(cx);
+    // Default model - used as fallback
+    let active_model_provider_name =
+        LanguageModelProviderId::from(settings.default_model.provider.clone());
+    let active_model_id = LanguageModelId::from(settings.default_model.model.clone());
 
-    fn to_selected_model(selection: &LanguageModelSelection) -> language_model::SelectedModel {
-        language_model::SelectedModel {
-            provider: LanguageModelProviderId::from(selection.provider.clone()),
-            model: LanguageModelId::from(selection.model.clone()),
-        }
-    }
-
-    let default = to_selected_model(&settings.default_model);
-    let inline_assistant = settings
+    // Inline assistant model
+    let inline_assistant_model = settings
         .inline_assistant_model
         .as_ref()
-        .map(to_selected_model);
-    let commit_message = settings
+        .unwrap_or(&settings.default_model);
+    let inline_assistant_provider_name =
+        LanguageModelProviderId::from(inline_assistant_model.provider.clone());
+    let inline_assistant_model_id = LanguageModelId::from(inline_assistant_model.model.clone());
+
+    // Commit message model
+    let commit_message_model = settings
         .commit_message_model
         .as_ref()
-        .map(to_selected_model);
-    let thread_summary = settings
+        .unwrap_or(&settings.default_model);
+    let commit_message_provider_name =
+        LanguageModelProviderId::from(commit_message_model.provider.clone());
+    let commit_message_model_id = LanguageModelId::from(commit_message_model.model.clone());
+
+    // Thread summary model
+    let thread_summary_model = settings
         .thread_summary_model
         .as_ref()
-        .map(to_selected_model);
+        .unwrap_or(&settings.default_model);
+    let thread_summary_provider_name =
+        LanguageModelProviderId::from(thread_summary_model.provider.clone());
+    let thread_summary_model_id = LanguageModelId::from(thread_summary_model.model.clone());
+
     let inline_alternatives = settings
         .inline_alternatives
         .iter()
-        .map(to_selected_model)
+        .map(|alternative| {
+            (
+                LanguageModelProviderId::from(alternative.provider.clone()),
+                LanguageModelId::from(alternative.model.clone()),
+            )
+        })
         .collect::<Vec<_>>();
 
     LanguageModelRegistry::global(cx).update(cx, |registry, cx| {
-        registry.select_default_model(Some(&default), cx);
-        registry.select_inline_assistant_model(inline_assistant.as_ref(), cx);
-        registry.select_commit_message_model(commit_message.as_ref(), cx);
-        registry.select_thread_summary_model(thread_summary.as_ref(), cx);
+        // Set the default model
+        registry.select_default_model(&active_model_provider_name, &active_model_id, cx);
+
+        // Set the specific models
+        registry.select_inline_assistant_model(
+            &inline_assistant_provider_name,
+            &inline_assistant_model_id,
+            cx,
+        );
+        registry.select_commit_message_model(
+            &commit_message_provider_name,
+            &commit_message_model_id,
+            cx,
+        );
+        registry.select_thread_summary_model(
+            &thread_summary_provider_name,
+            &thread_summary_model_id,
+            cx,
+        );
+
+        // Set the alternatives
         registry.select_inline_alternative_models(inline_alternatives, cx);
     });
 }

crates/assistant/src/assistant_panel.rs

@@ -27,7 +27,7 @@ use language_model::{
 };
 use project::Project;
 use prompt_library::{PromptLibrary, open_prompt_library};
-use prompt_store::{PromptBuilder, PromptId};
+use prompt_store::PromptBuilder;
 
 use search::{BufferSearchBar, buffer_search::DivRegistrar};
 use settings::{Settings, update_settings_file};
@@ -62,7 +62,7 @@ pub fn init(cx: &mut App) {
                     if let Some(panel) = workspace.panel::<AssistantPanel>(cx) {
                         workspace.focus_panel::<AssistantPanel>(window, cx);
                         panel.update(cx, |panel, cx| {
-                            panel.deploy_prompt_library(&OpenPromptLibrary::default(), window, cx)
+                            panel.deploy_prompt_library(&OpenPromptLibrary, window, cx)
                         });
                     }
                 });
@@ -272,10 +272,7 @@ impl AssistantPanel {
                                     menu.context(focus_handle.clone())
                                         .action("New Chat", Box::new(NewChat))
                                         .action("History", Box::new(DeployHistory))
-                                        .action(
-                                            "Prompt Library",
-                                            Box::new(OpenPromptLibrary::default()),
-                                        )
+                                        .action("Prompt Library", Box::new(OpenPromptLibrary))
                                         .action("Configure", Box::new(ShowConfiguration))
                                         .action(zoom_label, Box::new(ToggleZoom))
                                 }))
@@ -1046,7 +1043,7 @@ impl AssistantPanel {
 
     fn deploy_prompt_library(
         &mut self,
-        action: &OpenPromptLibrary,
+        _: &OpenPromptLibrary,
         _window: &mut Window,
         cx: &mut Context<Self>,
     ) {
@@ -1060,7 +1057,6 @@ impl AssistantPanel {
                     None,
                 ))
             }),
-            action.prompt_to_focus.map(|uuid| PromptId::User { uuid }),
             cx,
         )
         .detach_and_log_err(cx);

crates/assistant/src/inline_assistant.rs

@@ -37,7 +37,7 @@ use language_model::{
     ConfiguredModel, LanguageModel, LanguageModelRegistry, LanguageModelRequest,
     LanguageModelRequestMessage, LanguageModelTextStream, Role, report_assistant_event,
 };
-use language_model_selector::{LanguageModelSelector, LanguageModelSelectorPopoverMenu, ModelType};
+use language_model_selector::{LanguageModelSelector, LanguageModelSelectorPopoverMenu};
 use multi_buffer::MultiBufferRow;
 use parking_lot::Mutex;
 use project::{CodeAction, LspAction, ProjectTransaction};
@@ -1766,7 +1766,6 @@ impl PromptEditor {
                             move |settings, _| settings.set_model(model.clone()),
                         );
                     },
-                    ModelType::Default,
                     window,
                     cx,
                 )
@@ -2979,8 +2978,6 @@ impl CodegenAlternative {
         });
 
         Ok(LanguageModelRequest {
-            thread_id: None,
-            prompt_id: None,
             messages,
             tools: Vec::new(),
             stop: Vec::new(),

crates/assistant/src/terminal_inline_assistant.rs

@@ -19,7 +19,7 @@ use language_model::{
     ConfiguredModel, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage,
     Role, report_assistant_event,
 };
-use language_model_selector::{LanguageModelSelector, LanguageModelSelectorPopoverMenu, ModelType};
+use language_model_selector::{LanguageModelSelector, LanguageModelSelectorPopoverMenu};
 use prompt_store::PromptBuilder;
 use settings::{Settings, update_settings_file};
 use std::{
@@ -292,8 +292,6 @@ impl TerminalInlineAssistant {
         });
 
         Ok(LanguageModelRequest {
-            thread_id: None,
-            prompt_id: None,
             messages,
             tools: Vec::new(),
             stop: Vec::new(),
@@ -755,7 +753,6 @@ impl PromptEditor {
                             move |settings, _| settings.set_model(model.clone()),
                         );
                     },
-                    ModelType::Default,
                     window,
                     cx,
                 )

crates/assistant_context_editor/src/context.rs

@@ -2373,7 +2373,7 @@ impl AssistantContext {
                                     LanguageModelCompletionEvent::Stop(reason) => {
                                         stop_reason = reason;
                                     }
-                                    LanguageModelCompletionEvent::Thinking { text: chunk, .. } => {
+                                    LanguageModelCompletionEvent::Thinking(chunk) => {
                                         if thought_process_stack.is_empty() {
                                             let start =
                                                 buffer.anchor_before(message_old_end_offset);
@@ -2555,8 +2555,6 @@ impl AssistantContext {
         }
 
         let mut completion_request = LanguageModelRequest {
-            thread_id: None,
-            prompt_id: None,
             messages: Vec::new(),
             tools: Vec::new(),
             stop: Vec::new(),

crates/assistant_context_editor/src/context_editor.rs

@@ -39,7 +39,7 @@ use language_model::{
     Role,
 };
 use language_model_selector::{
-    LanguageModelSelector, LanguageModelSelectorPopoverMenu, ModelType, ToggleModelSelector,
+    LanguageModelSelector, LanguageModelSelectorPopoverMenu, ToggleModelSelector,
 };
 use multi_buffer::MultiBufferRow;
 use picker::Picker;
@@ -298,7 +298,6 @@ impl ContextEditor {
                             move |settings, _| settings.set_model(model.clone()),
                         );
                     },
-                    ModelType::Default,
                     window,
                     cx,
                 )
@@ -1814,10 +1813,7 @@ impl ContextEditor {
                     .selections
                     .all_adjusted(cx)
                     .into_iter()
-                    .filter_map(|s| {
-                        (!s.is_empty())
-                            .then(|| snapshot.anchor_after(s.start)..snapshot.anchor_before(s.end))
-                    })
+                    .map(|s| snapshot.anchor_after(s.start)..snapshot.anchor_before(s.end))
                     .collect::<Vec<_>>()
             });
             Some((selections, buffer))

crates/assistant_slash_commands/src/default_command.rs

@@ -54,9 +54,9 @@ impl SlashCommand for DefaultSlashCommand {
         cx: &mut App,
     ) -> Task<SlashCommandResult> {
         let store = PromptStore::global(cx);
-        cx.spawn(async move |cx| {
+        cx.background_spawn(async move {
             let store = store.await?;
-            let prompts = store.read_with(cx, |store, _cx| store.default_prompt_metadata())?;
+            let prompts = store.default_prompt_metadata();
 
             let mut text = String::new();
             text.push('\n');

crates/assistant_slash_commands/src/prompt_command.rs

@@ -5,7 +5,7 @@ use assistant_slash_command::{
 };
 use gpui::{Task, WeakEntity};
 use language::{BufferSnapshot, LspAdapterDelegate};
-use prompt_store::{PromptMetadata, PromptStore};
+use prompt_store::PromptStore;
 use std::sync::{Arc, atomic::AtomicBool};
 use ui::prelude::*;
 use workspace::Workspace;
@@ -43,11 +43,8 @@ impl SlashCommand for PromptSlashCommand {
     ) -> Task<Result<Vec<ArgumentCompletion>>> {
         let store = PromptStore::global(cx);
         let query = arguments.to_owned().join(" ");
-        cx.spawn(async move |cx| {
-            let prompts: Vec<PromptMetadata> = store
-                .await?
-                .read_with(cx, |store, cx| store.search(query, cx))?
-                .await;
+        cx.background_spawn(async move {
+            let prompts = store.await?.search(query).await;
             Ok(prompts
                 .into_iter()
                 .filter_map(|prompt| {
@@ -80,18 +77,14 @@ impl SlashCommand for PromptSlashCommand {
 
         let store = PromptStore::global(cx);
         let title = SharedString::from(title.clone());
-        let prompt = cx.spawn({
+        let prompt = cx.background_spawn({
             let title = title.clone();
-            async move |cx| {
+            async move {
                 let store = store.await?;
-                let body = store
-                    .read_with(cx, |store, cx| {
-                        let prompt_id = store
-                            .id_for_title(&title)
-                            .with_context(|| format!("no prompt found with title {:?}", title))?;
-                        anyhow::Ok(store.load(prompt_id, cx))
-                    })??
-                    .await?;
+                let prompt_id = store
+                    .id_for_title(&title)
+                    .with_context(|| format!("no prompt found with title {:?}", title))?;
+                let body = store.load(prompt_id).await?;
                 anyhow::Ok(body)
             }
         });

crates/assistant_tools/src/assistant_tools.rs

@@ -9,13 +9,13 @@ mod delete_path_tool;
 mod diagnostics_tool;
 mod edit_file_tool;
 mod fetch_tool;
-mod grep_tool;
 mod list_directory_tool;
 mod move_path_tool;
 mod now_tool;
 mod open_tool;
 mod path_search_tool;
 mod read_file_tool;
+mod regex_search_tool;
 mod rename_tool;
 mod replace;
 mod schema;
@@ -44,12 +44,12 @@ use crate::delete_path_tool::DeletePathTool;
 use crate::diagnostics_tool::DiagnosticsTool;
 use crate::edit_file_tool::EditFileTool;
 use crate::fetch_tool::FetchTool;
-use crate::grep_tool::GrepTool;
 use crate::list_directory_tool::ListDirectoryTool;
 use crate::now_tool::NowTool;
 use crate::open_tool::OpenTool;
 use crate::path_search_tool::PathSearchTool;
 use crate::read_file_tool::ReadFileTool;
+use crate::regex_search_tool::RegexSearchTool;
 use crate::rename_tool::RenameTool;
 use crate::symbol_info_tool::SymbolInfoTool;
 use crate::terminal_tool::TerminalTool;
@@ -77,7 +77,7 @@ pub fn init(http_client: Arc<HttpClientWithUrl>, cx: &mut App) {
     registry.register_tool(ContentsTool);
     registry.register_tool(PathSearchTool);
     registry.register_tool(ReadFileTool);
-    registry.register_tool(GrepTool);
+    registry.register_tool(RegexSearchTool);
     registry.register_tool(RenameTool);
     registry.register_tool(ThinkingTool);
     registry.register_tool(FetchTool::new(http_client));

crates/assistant_tools/src/batch_tool.rs

@@ -43,7 +43,7 @@ pub struct BatchToolInput {
     ///       }
     ///     },
     ///     {
-    ///       "name": "grep",
+    ///       "name": "regex_search",
     ///       "input": {
     ///         "regex": "fn run\\("
     ///       }
@@ -91,7 +91,7 @@ pub struct BatchToolInput {
     /// {
     ///   "invocations": [
     ///     {
-    ///       "name": "grep",
+    ///       "name": "regex_search",
     ///       "input": {
     ///         "regex": "impl Database"
     ///       }

crates/assistant_tools/src/grep_tool.rs

@@ -1,424 +0,0 @@
-use crate::schema::json_schema_for;
-use anyhow::{Result, anyhow};
-use assistant_tool::{ActionLog, Tool, ToolResult};
-use futures::StreamExt;
-use gpui::{App, Entity, Task};
-use language::OffsetRangeExt;
-use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
-use project::{
-    Project,
-    search::{SearchQuery, SearchResult},
-};
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
-use std::{cmp, fmt::Write, sync::Arc};
-use ui::IconName;
-use util::markdown::MarkdownString;
-use util::paths::PathMatcher;
-
-#[derive(Debug, Serialize, Deserialize, JsonSchema)]
-pub struct GrepToolInput {
-    /// A regex pattern to search for in the entire project. Note that the regex
-    /// will be parsed by the Rust `regex` crate.
-    pub regex: String,
-
-    /// A glob pattern for the paths of files to include in the search.
-    /// Supports standard glob patterns like "**/*.rs" or "src/**/*.ts".
-    /// If omitted, all files in the project will be searched.
-    pub include_pattern: Option<String>,
-
-    /// Optional starting position for paginated results (0-based).
-    /// When not provided, starts from the beginning.
-    #[serde(default)]
-    pub offset: u32,
-
-    /// Whether the regex is case-sensitive. Defaults to false (case-insensitive).
-    #[serde(default)]
-    pub case_sensitive: bool,
-}
-
-impl GrepToolInput {
-    /// Which page of search results this is.
-    pub fn page(&self) -> u32 {
-        1 + (self.offset / RESULTS_PER_PAGE)
-    }
-}
-
-const RESULTS_PER_PAGE: u32 = 20;
-
-pub struct GrepTool;
-
-impl Tool for GrepTool {
-    fn name(&self) -> String {
-        "grep".into()
-    }
-
-    fn needs_confirmation(&self, _: &serde_json::Value, _: &App) -> bool {
-        false
-    }
-
-    fn description(&self) -> String {
-        include_str!("./grep_tool/description.md").into()
-    }
-
-    fn icon(&self) -> IconName {
-        IconName::Regex
-    }
-
-    fn input_schema(&self, format: LanguageModelToolSchemaFormat) -> Result<serde_json::Value> {
-        json_schema_for::<GrepToolInput>(format)
-    }
-
-    fn ui_text(&self, input: &serde_json::Value) -> String {
-        match serde_json::from_value::<GrepToolInput>(input.clone()) {
-            Ok(input) => {
-                let page = input.page();
-                let regex_str = MarkdownString::inline_code(&input.regex);
-                let case_info = if input.case_sensitive {
-                    " (case-sensitive)"
-                } else {
-                    ""
-                };
-
-                if page > 1 {
-                    format!("Get page {page} of search results for regex {regex_str}{case_info}")
-                } else {
-                    format!("Search files for regex {regex_str}{case_info}")
-                }
-            }
-            Err(_) => "Search with regex".to_string(),
-        }
-    }
-
-    fn run(
-        self: Arc<Self>,
-        input: serde_json::Value,
-        _messages: &[LanguageModelRequestMessage],
-        project: Entity<Project>,
-        _action_log: Entity<ActionLog>,
-        cx: &mut App,
-    ) -> ToolResult {
-        const CONTEXT_LINES: u32 = 2;
-
-        let input = match serde_json::from_value::<GrepToolInput>(input) {
-            Ok(input) => input,
-            Err(error) => {
-                return Task::ready(Err(anyhow!("Failed to parse input: {}", error))).into();
-            }
-        };
-
-        let include_matcher = match PathMatcher::new(
-            input
-                .include_pattern
-                .as_ref()
-                .into_iter()
-                .collect::<Vec<_>>(),
-        ) {
-            Ok(matcher) => matcher,
-            Err(error) => {
-                return Task::ready(Err(anyhow!("invalid include glob pattern: {}", error))).into();
-            }
-        };
-
-        let query = match SearchQuery::regex(
-            &input.regex,
-            false,
-            input.case_sensitive,
-            false,
-            false,
-            include_matcher,
-            PathMatcher::default(), // For now, keep it simple and don't enable an exclude pattern.
-            true, // Always match file include pattern against *full project paths* that start with a project root.
-            None,
-        ) {
-            Ok(query) => query,
-            Err(error) => return Task::ready(Err(error)).into(),
-        };
-
-        let results = project.update(cx, |project, cx| project.search(query, cx));
-
-        cx.spawn(async move|cx|  {
-            futures::pin_mut!(results);
-
-            let mut output = String::new();
-            let mut skips_remaining = input.offset;
-            let mut matches_found = 0;
-            let mut has_more_matches = false;
-
-            while let Some(SearchResult::Buffer { buffer, ranges }) = results.next().await {
-                if ranges.is_empty() {
-                    continue;
-                }
-
-                buffer.read_with(cx, |buffer, cx| -> Result<(), anyhow::Error> {
-                    if let Some(path) = buffer.file().map(|file| file.full_path(cx)) {
-                        let mut file_header_written = false;
-                        let mut ranges = ranges
-                            .into_iter()
-                            .map(|range| {
-                                let mut point_range = range.to_point(buffer);
-                                point_range.start.row =
-                                    point_range.start.row.saturating_sub(CONTEXT_LINES);
-                                point_range.start.column = 0;
-                                point_range.end.row = cmp::min(
-                                    buffer.max_point().row,
-                                    point_range.end.row + CONTEXT_LINES,
-                                );
-                                point_range.end.column = buffer.line_len(point_range.end.row);
-                                point_range
-                            })
-                            .peekable();
-
-                        while let Some(mut range) = ranges.next() {
-                            if skips_remaining > 0 {
-                                skips_remaining -= 1;
-                                continue;
-                            }
-
-                            // We'd already found a full page of matches, and we just found one more.
-                            if matches_found >= RESULTS_PER_PAGE {
-                                has_more_matches = true;
-                                return Ok(());
-                            }
-
-                            while let Some(next_range) = ranges.peek() {
-                                if range.end.row >= next_range.start.row {
-                                    range.end = next_range.end;
-                                    ranges.next();
-                                } else {
-                                    break;
-                                }
-                            }
-
-                            if !file_header_written {
-                                writeln!(output, "\n## Matches in {}", path.display())?;
-                                file_header_written = true;
-                            }
-
-                            let start_line = range.start.row + 1;
-                            let end_line = range.end.row + 1;
-                            writeln!(output, "\n### Lines {start_line}-{end_line}\n```")?;
-                            output.extend(buffer.text_for_range(range));
-                            output.push_str("\n```\n");
-
-                            matches_found += 1;
-                        }
-                    }
-
-                    Ok(())
-                })??;
-            }
-
-            if matches_found == 0 {
-                Ok("No matches found".to_string())
-            } else if has_more_matches {
-                Ok(format!(
-                    "Showing matches {}-{} (there were more matches found; use offset: {} to see next page):\n{output}",
-                    input.offset + 1,
-                    input.offset + matches_found,
-                    input.offset + RESULTS_PER_PAGE,
-                ))
-            } else {
-                Ok(format!("Found {matches_found} matches:\n{output}"))
-            }
-        }).into()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use assistant_tool::Tool;
-    use gpui::{AppContext, TestAppContext};
-    use project::{FakeFs, Project};
-    use settings::SettingsStore;
-    use util::path;
-
-    #[gpui::test]
-    async fn test_grep_tool_with_include_pattern(cx: &mut TestAppContext) {
-        init_test(cx);
-
-        let fs = FakeFs::new(cx.executor().clone());
-        fs.insert_tree(
-            "/root",
-            serde_json::json!({
-                "src": {
-                    "main.rs": "fn main() {\n    println!(\"Hello, world!\");\n}",
-                    "utils": {
-                        "helper.rs": "fn helper() {\n    println!(\"I'm a helper!\");\n}",
-                    },
-                },
-                "tests": {
-                    "test_main.rs": "fn test_main() {\n    assert!(true);\n}",
-                }
-            }),
-        )
-        .await;
-
-        let project = Project::test(fs.clone(), [path!("/root").as_ref()], cx).await;
-
-        // Test with include pattern for Rust files inside the root of the project
-        let input = serde_json::to_value(GrepToolInput {
-            regex: "println".to_string(),
-            include_pattern: Some("root/**/*.rs".to_string()),
-            offset: 0,
-            case_sensitive: false,
-        })
-        .unwrap();
-
-        let result = run_grep_tool(input, project.clone(), cx).await;
-        assert!(result.contains("main.rs"), "Should find matches in main.rs");
-        assert!(
-            result.contains("helper.rs"),
-            "Should find matches in helper.rs"
-        );
-        assert!(
-            !result.contains("test_main.rs"),
-            "Should not include test_main.rs even though it's a .rs file (because it doesn't have the pattern)"
-        );
-
-        // Test with include pattern for src directory only
-        let input = serde_json::to_value(GrepToolInput {
-            regex: "fn".to_string(),
-            include_pattern: Some("root/**/src/**".to_string()),
-            offset: 0,
-            case_sensitive: false,
-        })
-        .unwrap();
-
-        let result = run_grep_tool(input, project.clone(), cx).await;
-        assert!(
-            result.contains("main.rs"),
-            "Should find matches in src/main.rs"
-        );
-        assert!(
-            result.contains("helper.rs"),
-            "Should find matches in src/utils/helper.rs"
-        );
-        assert!(
-            !result.contains("test_main.rs"),
-            "Should not include test_main.rs as it's not in src directory"
-        );
-
-        // Test with empty include pattern (should default to all files)
-        let input = serde_json::to_value(GrepToolInput {
-            regex: "fn".to_string(),
-            include_pattern: None,
-            offset: 0,
-            case_sensitive: false,
-        })
-        .unwrap();
-
-        let result = run_grep_tool(input, project.clone(), cx).await;
-        assert!(result.contains("main.rs"), "Should find matches in main.rs");
-        assert!(
-            result.contains("helper.rs"),
-            "Should find matches in helper.rs"
-        );
-        assert!(
-            result.contains("test_main.rs"),
-            "Should include test_main.rs"
-        );
-    }
-
-    #[gpui::test]
-    async fn test_grep_tool_with_case_sensitivity(cx: &mut TestAppContext) {
-        init_test(cx);
-
-        let fs = FakeFs::new(cx.executor().clone());
-        fs.insert_tree(
-            "/root",
-            serde_json::json!({
-                "case_test.txt": "This file has UPPERCASE and lowercase text.\nUPPERCASE patterns should match only with case_sensitive: true",
-            }),
-        )
-        .await;
-
-        let project = Project::test(fs.clone(), [path!("/root").as_ref()], cx).await;
-
-        // Test case-insensitive search (default)
-        let input = serde_json::to_value(GrepToolInput {
-            regex: "uppercase".to_string(),
-            include_pattern: Some("**/*.txt".to_string()),
-            offset: 0,
-            case_sensitive: false,
-        })
-        .unwrap();
-
-        let result = run_grep_tool(input, project.clone(), cx).await;
-        assert!(
-            result.contains("UPPERCASE"),
-            "Case-insensitive search should match uppercase"
-        );
-
-        // Test case-sensitive search
-        let input = serde_json::to_value(GrepToolInput {
-            regex: "uppercase".to_string(),
-            include_pattern: Some("**/*.txt".to_string()),
-            offset: 0,
-            case_sensitive: true,
-        })
-        .unwrap();
-
-        let result = run_grep_tool(input, project.clone(), cx).await;
-        assert!(
-            !result.contains("UPPERCASE"),
-            "Case-sensitive search should not match uppercase"
-        );
-
-        // Test case-sensitive search
-        let input = serde_json::to_value(GrepToolInput {
-            regex: "LOWERCASE".to_string(),
-            include_pattern: Some("**/*.txt".to_string()),
-            offset: 0,
-            case_sensitive: true,
-        })
-        .unwrap();
-
-        let result = run_grep_tool(input, project.clone(), cx).await;
-
-        assert!(
-            !result.contains("lowercase"),
-            "Case-sensitive search should match lowercase"
-        );
-
-        // Test case-sensitive search for lowercase pattern
-        let input = serde_json::to_value(GrepToolInput {
-            regex: "lowercase".to_string(),
-            include_pattern: Some("**/*.txt".to_string()),
-            offset: 0,
-            case_sensitive: true,
-        })
-        .unwrap();
-
-        let result = run_grep_tool(input, project.clone(), cx).await;
-        assert!(
-            result.contains("lowercase"),
-            "Case-sensitive search should match lowercase text"
-        );
-    }
-
-    async fn run_grep_tool(
-        input: serde_json::Value,
-        project: Entity<Project>,
-        cx: &mut TestAppContext,
-    ) -> String {
-        let tool = Arc::new(GrepTool);
-        let action_log = cx.new(|_cx| ActionLog::new(project.clone()));
-        let task = cx.update(|cx| tool.run(input, &[], project, action_log, cx));
-
-        match task.output.await {
-            Ok(result) => result,
-            Err(e) => panic!("Failed to run grep tool: {}", e),
-        }
-    }
-
-    fn init_test(cx: &mut TestAppContext) {
-        cx.update(|cx| {
-            let settings_store = SettingsStore::test(cx);
-            cx.set_global(settings_store);
-            language::init(cx);
-            Project::init_settings(cx);
-        });
-    }
-}

crates/assistant_tools/src/grep_tool/description.md

@@ -1,8 +0,0 @@
-Searches the contents of files in the project with a regular expression
-
-- Prefer this tool to path search when searching for symbols in the project, because you won't need to guess what path it's in.
-- Supports full regex syntax (eg. "log.*Error", "function\\s+\\w+", etc.)
-- Pass an `include_pattern` if you know how to narrow your search on the files system
-- Never use this tool to search for paths. Only search file contents with this tool.
-- Use this tool when you need to find files containing specific patterns
-- Results are paginated with 20 matches per page. Use the optional 'offset' parameter to request subsequent pages.

crates/assistant_tools/src/list_directory_tool/description.md

@@ -1 +1 @@
-Lists files and directories in a given path. Prefer the `grep` or `path_search` tools when searching the codebase.
+Lists files and directories in a given path. Prefer the `regex_search` or `path_search` tools when searching the codebase.

crates/assistant_tools/src/path_search_tool/description.md

@@ -2,6 +2,6 @@ Fast file pattern matching tool that works with any codebase size
 
 - Supports glob patterns like "**/*.js" or "src/**/*.ts"
 - Returns matching file paths sorted alphabetically
-- Prefer the `grep` tool to this tool when searching for symbols unless you have specific information about paths.
+- Prefer the `regex_search` tool to this tool when searching for symbols unless you have specific information about paths.
 - Use this tool when you need to find files by name patterns
 - Results are paginated with 50 matches per page. Use the optional 'offset' parameter to request subsequent pages.

crates/assistant_tools/src/read_file_tool/description.md

@@ -1,3 +1,6 @@
 Reads the content of the given file in the project.
 
-- Never attempt to read a path that hasn't been previously mentioned.
+If the file is too big to read all at once, and neither a start line
+nor an end line was specified, then this returns an outline of the
+file's symbols (with line numbers) instead of the file's contents,
+so that it can be called again with line ranges.

crates/assistant_tools/src/regex_search_tool.rs

@@ -0,0 +1,206 @@
+use crate::schema::json_schema_for;
+use anyhow::{Result, anyhow};
+use assistant_tool::{ActionLog, Tool, ToolResult};
+use futures::StreamExt;
+use gpui::{App, Entity, Task};
+use language::OffsetRangeExt;
+use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
+use project::{
+    Project,
+    search::{SearchQuery, SearchResult},
+};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::{cmp, fmt::Write, sync::Arc};
+use ui::IconName;
+use util::markdown::MarkdownString;
+use util::paths::PathMatcher;
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct RegexSearchToolInput {
+    /// A regex pattern to search for in the entire project. Note that the regex
+    /// will be parsed by the Rust `regex` crate.
+    pub regex: String,
+
+    /// Optional starting position for paginated results (0-based).
+    /// When not provided, starts from the beginning.
+    #[serde(default)]
+    pub offset: u32,
+
+    /// Whether the regex is case-sensitive. Defaults to false (case-insensitive).
+    #[serde(default)]
+    pub case_sensitive: bool,
+}
+
+impl RegexSearchToolInput {
+    /// Which page of search results this is.
+    pub fn page(&self) -> u32 {
+        1 + (self.offset / RESULTS_PER_PAGE)
+    }
+}
+
+const RESULTS_PER_PAGE: u32 = 20;
+
+pub struct RegexSearchTool;
+
+impl Tool for RegexSearchTool {
+    fn name(&self) -> String {
+        "regex_search".into()
+    }
+
+    fn needs_confirmation(&self, _: &serde_json::Value, _: &App) -> bool {
+        false
+    }
+
+    fn description(&self) -> String {
+        include_str!("./regex_search_tool/description.md").into()
+    }
+
+    fn icon(&self) -> IconName {
+        IconName::Regex
+    }
+
+    fn input_schema(&self, format: LanguageModelToolSchemaFormat) -> Result<serde_json::Value> {
+        json_schema_for::<RegexSearchToolInput>(format)
+    }
+
+    fn ui_text(&self, input: &serde_json::Value) -> String {
+        match serde_json::from_value::<RegexSearchToolInput>(input.clone()) {
+            Ok(input) => {
+                let page = input.page();
+                let regex_str = MarkdownString::inline_code(&input.regex);
+                let case_info = if input.case_sensitive {
+                    " (case-sensitive)"
+                } else {
+                    ""
+                };
+
+                if page > 1 {
+                    format!("Get page {page} of search results for regex {regex_str}{case_info}")
+                } else {
+                    format!("Search files for regex {regex_str}{case_info}")
+                }
+            }
+            Err(_) => "Search with regex".to_string(),
+        }
+    }
+
+    fn run(
+        self: Arc<Self>,
+        input: serde_json::Value,
+        _messages: &[LanguageModelRequestMessage],
+        project: Entity<Project>,
+        _action_log: Entity<ActionLog>,
+        cx: &mut App,
+    ) -> ToolResult {
+        const CONTEXT_LINES: u32 = 2;
+
+        let (offset, regex, case_sensitive) =
+            match serde_json::from_value::<RegexSearchToolInput>(input) {
+                Ok(input) => (input.offset, input.regex, input.case_sensitive),
+                Err(err) => return Task::ready(Err(anyhow!(err))).into(),
+            };
+
+        let query = match SearchQuery::regex(
+            &regex,
+            false,
+            case_sensitive,
+            false,
+            false,
+            PathMatcher::default(),
+            PathMatcher::default(),
+            None,
+        ) {
+            Ok(query) => query,
+            Err(error) => return Task::ready(Err(error)).into(),
+        };
+
+        let results = project.update(cx, |project, cx| project.search(query, cx));
+
+        cx.spawn(async move|cx|  {
+            futures::pin_mut!(results);
+
+            let mut output = String::new();
+            let mut skips_remaining = offset;
+            let mut matches_found = 0;
+            let mut has_more_matches = false;
+
+            while let Some(SearchResult::Buffer { buffer, ranges }) = results.next().await {
+                if ranges.is_empty() {
+                    continue;
+                }
+
+                buffer.read_with(cx, |buffer, cx| -> Result<(), anyhow::Error> {
+                    if let Some(path) = buffer.file().map(|file| file.full_path(cx)) {
+                        let mut file_header_written = false;
+                        let mut ranges = ranges
+                            .into_iter()
+                            .map(|range| {
+                                let mut point_range = range.to_point(buffer);
+                                point_range.start.row =
+                                    point_range.start.row.saturating_sub(CONTEXT_LINES);
+                                point_range.start.column = 0;
+                                point_range.end.row = cmp::min(
+                                    buffer.max_point().row,
+                                    point_range.end.row + CONTEXT_LINES,
+                                );
+                                point_range.end.column = buffer.line_len(point_range.end.row);
+                                point_range
+                            })
+                            .peekable();
+
+                        while let Some(mut range) = ranges.next() {
+                            if skips_remaining > 0 {
+                                skips_remaining -= 1;
+                                continue;
+                            }
+
+                            // We'd already found a full page of matches, and we just found one more.
+                            if matches_found >= RESULTS_PER_PAGE {
+                                has_more_matches = true;
+                                return Ok(());
+                            }
+
+                            while let Some(next_range) = ranges.peek() {
+                                if range.end.row >= next_range.start.row {
+                                    range.end = next_range.end;
+                                    ranges.next();
+                                } else {
+                                    break;
+                                }
+                            }
+
+                            if !file_header_written {
+                                writeln!(output, "\n## Matches in {}", path.display())?;
+                                file_header_written = true;
+                            }
+
+                            let start_line = range.start.row + 1;
+                            let end_line = range.end.row + 1;
+                            writeln!(output, "\n### Lines {start_line}-{end_line}\n```")?;
+                            output.extend(buffer.text_for_range(range));
+                            output.push_str("\n```\n");
+
+                            matches_found += 1;
+                        }
+                    }
+
+                    Ok(())
+                })??;
+            }
+
+            if matches_found == 0 {
+                Ok("No matches found".to_string())
+            } else if has_more_matches {
+                Ok(format!(
+                    "Showing matches {}-{} (there were more matches found; use offset: {} to see next page):\n{output}",
+                    offset + 1,
+                    offset + matches_found,
+                    offset + RESULTS_PER_PAGE,
+                ))
+            } else {
+                Ok(format!("Found {matches_found} matches:\n{output}"))
+            }
+        }).into()
+    }
+}

crates/assistant_tools/src/regex_search_tool/description.md

@@ -0,0 +1,6 @@
+Searches the entire project for the given regular expression.
+
+- Prefer this tool when searching for files containing symbols in the project.
+- Supports full regex syntax (eg. "log.*Error", "function\\s+\\w+", etc.)
+- Use this tool when you need to find files containing specific patterns
+- Results are paginated with 20 matches per page. Use the optional 'offset' parameter to request subsequent pages.

crates/assistant_tools/src/replace.rs

@@ -14,7 +14,6 @@ pub async fn replace_exact(old: &str, new: &str, snapshot: &BufferSnapshot) -> O
         true,
         PathMatcher::new(iter::empty::<&str>()).ok()?,
         PathMatcher::new(iter::empty::<&str>()).ok()?,
-        false,
         None,
     )
     .log_err()?;
@@ -59,8 +58,10 @@ pub fn replace_with_flexible_indent(old: &str, new: &str, buffer: &BufferSnapsho
 
     let max_row = buffer.max_point().row;
 
-    'windows: for start_row in 0..max_row + 1 {
-        let end_row = start_row + old_lines.len().saturating_sub(1) as u32;
+    'windows: for start_row in 0..max_row.saturating_sub(old_lines.len() as u32 - 1) {
+        let mut common_leading = None;
+
+        let end_row = start_row + old_lines.len() as u32 - 1;
 
         if end_row > max_row {
             // The buffer ends before fully matching the pattern
@@ -75,14 +76,6 @@ pub fn replace_with_flexible_indent(old: &str, new: &str, buffer: &BufferSnapsho
         let mut window_lines = window_text.lines();
         let mut old_lines_iter = old_lines.iter();
 
-        let mut common_mismatch = None;
-
-        #[derive(Eq, PartialEq)]
-        enum Mismatch {
-            OverIndented(String),
-            UnderIndented(String),
-        }
-
         while let (Some(window_line), Some(old_line)) = (window_lines.next(), old_lines_iter.next())
         {
             let line_trimmed = window_line.trim_start();
@@ -95,24 +88,18 @@ pub fn replace_with_flexible_indent(old: &str, new: &str, buffer: &BufferSnapsho
                 continue;
             }
 
-            let line_mismatch = if window_line.len() > old_line.len() {
-                let prefix = window_line[..window_line.len() - old_line.len()].to_string();
-                Mismatch::UnderIndented(prefix)
-            } else {
-                let prefix = old_line[..old_line.len() - window_line.len()].to_string();
-                Mismatch::OverIndented(prefix)
-            };
+            let line_leading = &window_line[..window_line.len() - old_line.len()];
 
-            match &common_mismatch {
-                Some(common_mismatch) if common_mismatch != &line_mismatch => {
+            match &common_leading {
+                Some(common_leading) if common_leading != line_leading => {
                     continue 'windows;
                 }
                 Some(_) => (),
-                None => common_mismatch = Some(line_mismatch),
+                None => common_leading = Some(line_leading.to_string()),
             }
         }
 
-        if let Some(common_mismatch) = &common_mismatch {
+        if let Some(common_leading) = common_leading {
             let line_ending = buffer.line_ending();
             let replacement = new_lines
                 .iter()
@@ -120,13 +107,7 @@ pub fn replace_with_flexible_indent(old: &str, new: &str, buffer: &BufferSnapsho
                     if new_line.trim().is_empty() {
                         new_line.to_string()
                     } else {
-                        match common_mismatch {
-                            Mismatch::UnderIndented(prefix) => prefix.to_string() + new_line,
-                            Mismatch::OverIndented(prefix) => new_line
-                                .strip_prefix(prefix)
-                                .unwrap_or(new_line)
-                                .to_string(),
-                        }
+                        common_leading.to_string() + new_line
                     }
                 })
                 .collect::<Vec<_>>()
@@ -168,123 +149,14 @@ fn lines_with_min_indent(input: &str) -> (Vec<&str>, usize) {
 }
 
 #[cfg(test)]
-mod replace_exact_tests {
-    use super::*;
-    use gpui::TestAppContext;
-    use gpui::prelude::*;
-
-    #[gpui::test]
-    async fn basic(cx: &mut TestAppContext) {
-        let result = test_replace_exact(cx, "let x = 41;", "let x = 41;", "let x = 42;").await;
-        assert_eq!(result, Some("let x = 42;".to_string()));
-    }
-
-    #[gpui::test]
-    async fn no_match(cx: &mut TestAppContext) {
-        let result = test_replace_exact(cx, "let x = 41;", "let y = 42;", "let y = 43;").await;
-        assert_eq!(result, None);
-    }
-
-    #[gpui::test]
-    async fn multi_line(cx: &mut TestAppContext) {
-        let whole = "fn example() {\n    let x = 41;\n    println!(\"x = {}\", x);\n}";
-        let old_text = "    let x = 41;\n    println!(\"x = {}\", x);";
-        let new_text = "    let x = 42;\n    println!(\"x = {}\", x);";
-        let result = test_replace_exact(cx, whole, old_text, new_text).await;
-        assert_eq!(
-            result,
-            Some("fn example() {\n    let x = 42;\n    println!(\"x = {}\", x);\n}".to_string())
-        );
-    }
-
-    #[gpui::test]
-    async fn multiple_occurrences(cx: &mut TestAppContext) {
-        let whole = "let x = 41;\nlet y = 41;\nlet z = 41;";
-        let result = test_replace_exact(cx, whole, "let x = 41;", "let x = 42;").await;
-        assert_eq!(
-            result,
-            Some("let x = 42;\nlet y = 41;\nlet z = 41;".to_string())
-        );
-    }
-
-    #[gpui::test]
-    async fn empty_buffer(cx: &mut TestAppContext) {
-        let result = test_replace_exact(cx, "", "let x = 41;", "let x = 42;").await;
-        assert_eq!(result, None);
-    }
-
-    #[gpui::test]
-    async fn partial_match(cx: &mut TestAppContext) {
-        let whole = "let x = 41; let y = 42;";
-        let result = test_replace_exact(cx, whole, "let x = 41", "let x = 42").await;
-        assert_eq!(result, Some("let x = 42; let y = 42;".to_string()));
-    }
-
-    #[gpui::test]
-    async fn whitespace_sensitive(cx: &mut TestAppContext) {
-        let result = test_replace_exact(cx, "let x = 41;", " let x = 41;", "let x = 42;").await;
-        assert_eq!(result, None);
-    }
-
-    #[gpui::test]
-    async fn entire_buffer(cx: &mut TestAppContext) {
-        let result = test_replace_exact(cx, "let x = 41;", "let x = 41;", "let x = 42;").await;
-        assert_eq!(result, Some("let x = 42;".to_string()));
-    }
-
-    async fn test_replace_exact(
-        cx: &mut TestAppContext,
-        whole: &str,
-        old: &str,
-        new: &str,
-    ) -> Option<String> {
-        let buffer = cx.new(|cx| language::Buffer::local(whole, cx));
-
-        let buffer_snapshot = buffer.read_with(cx, |buffer, _cx| buffer.snapshot());
-
-        let diff = replace_exact(old, new, &buffer_snapshot).await;
-        diff.map(|diff| {
-            buffer.update(cx, |buffer, cx| {
-                let _ = buffer.apply_diff(diff, cx);
-                buffer.text()
-            })
-        })
-    }
-}
-
-#[cfg(test)]
-mod flexible_indent_tests {
+mod tests {
     use super::*;
     use gpui::TestAppContext;
     use gpui::prelude::*;
     use unindent::Unindent;
 
     #[gpui::test]
-    fn test_underindented_single_line(cx: &mut TestAppContext) {
-        let cur = "        let a = 41;".to_string();
-        let old = "    let a = 41;".to_string();
-        let new = "    let a = 42;".to_string();
-        let exp = "        let a = 42;".to_string();
-
-        let result = test_replace_with_flexible_indent(cx, &cur, &old, &new);
-
-        assert_eq!(result, Some(exp.to_string()))
-    }
-
-    #[gpui::test]
-    fn test_overindented_single_line(cx: &mut TestAppContext) {
-        let cur = "    let a = 41;".to_string();
-        let old = "        let a = 41;".to_string();
-        let new = "        let a = 42;".to_string();
-        let exp = "    let a = 42;".to_string();
-
-        let result = test_replace_with_flexible_indent(cx, &cur, &old, &new);
-
-        assert_eq!(result, Some(exp.to_string()))
-    }
-
-    #[gpui::test]
-    fn test_underindented_multi_line(cx: &mut TestAppContext) {
+    fn test_replace_consistent_indentation(cx: &mut TestAppContext) {
         let whole = r#"
             fn test() {
                 let x = 5;
@@ -321,33 +193,6 @@ mod flexible_indent_tests {
         );
     }
 
-    #[gpui::test]
-    fn test_overindented_multi_line(cx: &mut TestAppContext) {
-        let cur = r#"
-            fn foo() {
-                let a = 41;
-                let b = 3.13;
-            }
-        "#
-        .unindent();
-
-        // 6 space indent instead of 4
-        let old = "      let a = 41;\n      let b = 3.13;";
-        let new = "      let a = 42;\n      let b = 3.14;";
-
-        let expected = r#"
-            fn foo() {
-                let a = 42;
-                let b = 3.14;
-            }
-        "#
-        .unindent();
-
-        let result = test_replace_with_flexible_indent(cx, &cur, &old, &new);
-
-        assert_eq!(result, Some(expected.to_string()))
-    }
-
     #[gpui::test]
     fn test_replace_inconsistent_indentation(cx: &mut TestAppContext) {
         let whole = r#"
@@ -420,6 +265,7 @@ mod flexible_indent_tests {
 
     #[gpui::test]
     fn test_replace_no_match(cx: &mut TestAppContext) {
+        // Test with no match
         let whole = r#"
             fn test() {
                 let x = 5;
@@ -470,71 +316,6 @@ mod flexible_indent_tests {
         );
     }
 
-    #[gpui::test]
-    fn test_replace_whole_is_shorter_than_old(cx: &mut TestAppContext) {
-        let whole = r#"
-            let x = 5;
-        "#
-        .unindent();
-
-        let old = r#"
-            let x = 5;
-            let y = 10;
-        "#
-        .unindent();
-
-        let new = r#"
-            let x = 5;
-            let y = 20;
-        "#
-        .unindent();
-
-        assert_eq!(
-            test_replace_with_flexible_indent(cx, &whole, &old, &new),
-            None
-        );
-    }
-
-    #[gpui::test]
-    fn test_replace_old_is_empty(cx: &mut TestAppContext) {
-        let whole = r#"
-            fn test() {
-                let x = 5;
-            }
-        "#
-        .unindent();
-
-        let old = "";
-        let new = r#"
-            let y = 10;
-        "#
-        .unindent();
-
-        assert_eq!(
-            test_replace_with_flexible_indent(cx, &whole, &old, &new),
-            None
-        );
-    }
-
-    #[gpui::test]
-    fn test_replace_whole_is_empty(cx: &mut TestAppContext) {
-        let whole = "";
-        let old = r#"
-            let x = 5;
-        "#
-        .unindent();
-
-        let new = r#"
-            let x = 10;
-        "#
-        .unindent();
-
-        assert_eq!(
-            test_replace_with_flexible_indent(cx, &whole, &old, &new),
-            None
-        );
-    }
-
     #[test]
     fn test_lines_with_min_indent() {
         // Empty string
@@ -722,133 +503,6 @@ mod flexible_indent_tests {
         );
     }
 
-    #[gpui::test]
-    async fn test_replace_exact_basic(cx: &mut TestAppContext) {
-        let buffer = cx.new(|cx| language::Buffer::local("let x = 41;", cx));
-        let snapshot = buffer.read_with(cx, |buffer, _cx| buffer.snapshot());
-
-        let diff = replace_exact("let x = 41;", "let x = 42;", &snapshot).await;
-        assert!(diff.is_some());
-
-        let diff = diff.unwrap();
-        assert_eq!(diff.edits.len(), 1);
-
-        let result = buffer.update(cx, |buffer, cx| {
-            let _ = buffer.apply_diff(diff, cx);
-            buffer.text()
-        });
-
-        assert_eq!(result, "let x = 42;");
-    }
-
-    #[gpui::test]
-    async fn test_replace_exact_no_match(cx: &mut TestAppContext) {
-        let buffer = cx.new(|cx| language::Buffer::local("let x = 41;", cx));
-        let snapshot = buffer.read_with(cx, |buffer, _cx| buffer.snapshot());
-
-        let diff = replace_exact("let y = 42;", "let y = 43;", &snapshot).await;
-        assert!(diff.is_none());
-    }
-
-    #[gpui::test]
-    async fn test_replace_exact_multi_line(cx: &mut TestAppContext) {
-        let buffer = cx.new(|cx| {
-            language::Buffer::local(
-                "fn example() {\n    let x = 41;\n    println!(\"x = {}\", x);\n}",
-                cx,
-            )
-        });
-        let snapshot = buffer.read_with(cx, |buffer, _cx| buffer.snapshot());
-
-        let old_text = "    let x = 41;\n    println!(\"x = {}\", x);";
-        let new_text = "    let x = 42;\n    println!(\"x = {}\", x);";
-        let diff = replace_exact(old_text, new_text, &snapshot).await;
-        assert!(diff.is_some());
-
-        let diff = diff.unwrap();
-        let result = buffer.update(cx, |buffer, cx| {
-            let _ = buffer.apply_diff(diff, cx);
-            buffer.text()
-        });
-
-        assert_eq!(
-            result,
-            "fn example() {\n    let x = 42;\n    println!(\"x = {}\", x);\n}"
-        );
-    }
-
-    #[gpui::test]
-    async fn test_replace_exact_multiple_occurrences(cx: &mut TestAppContext) {
-        let buffer =
-            cx.new(|cx| language::Buffer::local("let x = 41;\nlet y = 41;\nlet z = 41;", cx));
-        let snapshot = buffer.read_with(cx, |buffer, _cx| buffer.snapshot());
-
-        // Should replace only the first occurrence
-        let diff = replace_exact("let x = 41;", "let x = 42;", &snapshot).await;
-        assert!(diff.is_some());
-
-        let diff = diff.unwrap();
-        let result = buffer.update(cx, |buffer, cx| {
-            let _ = buffer.apply_diff(diff, cx);
-            buffer.text()
-        });
-
-        assert_eq!(result, "let x = 42;\nlet y = 41;\nlet z = 41;");
-    }
-
-    #[gpui::test]
-    async fn test_replace_exact_empty_buffer(cx: &mut TestAppContext) {
-        let buffer = cx.new(|cx| language::Buffer::local("", cx));
-        let snapshot = buffer.read_with(cx, |buffer, _cx| buffer.snapshot());
-
-        let diff = replace_exact("let x = 41;", "let x = 42;", &snapshot).await;
-        assert!(diff.is_none());
-    }
-
-    #[gpui::test]
-    async fn test_replace_exact_partial_match(cx: &mut TestAppContext) {
-        let buffer = cx.new(|cx| language::Buffer::local("let x = 41; let y = 42;", cx));
-        let snapshot = buffer.read_with(cx, |buffer, _cx| buffer.snapshot());
-
-        // Verify substring replacement actually works
-        let diff = replace_exact("let x = 41", "let x = 42", &snapshot).await;
-        assert!(diff.is_some());
-
-        let diff = diff.unwrap();
-        let result = buffer.update(cx, |buffer, cx| {
-            let _ = buffer.apply_diff(diff, cx);
-            buffer.text()
-        });
-
-        assert_eq!(result, "let x = 42; let y = 42;");
-    }
-
-    #[gpui::test]
-    async fn test_replace_exact_whitespace_sensitive(cx: &mut TestAppContext) {
-        let buffer = cx.new(|cx| language::Buffer::local("let x = 41;", cx));
-        let snapshot = buffer.read_with(cx, |buffer, _cx| buffer.snapshot());
-
-        let diff = replace_exact(" let x = 41;", "let x = 42;", &snapshot).await;
-        assert!(diff.is_none());
-    }
-
-    #[gpui::test]
-    async fn test_replace_exact_entire_buffer(cx: &mut TestAppContext) {
-        let buffer = cx.new(|cx| language::Buffer::local("let x = 41;", cx));
-        let snapshot = buffer.read_with(cx, |buffer, _cx| buffer.snapshot());
-
-        let diff = replace_exact("let x = 41;", "let x = 42;", &snapshot).await;
-        assert!(diff.is_some());
-
-        let diff = diff.unwrap();
-        let result = buffer.update(cx, |buffer, cx| {
-            let _ = buffer.apply_diff(diff, cx);
-            buffer.text()
-        });
-
-        assert_eq!(result, "let x = 42;");
-    }
-
     fn test_replace_with_flexible_indent(
         cx: &mut TestAppContext,
         whole: &str,

crates/bedrock/src/models.rs

@@ -84,10 +84,6 @@ pub enum Model {
 }
 
 impl Model {
-    pub fn default_fast() -> Self {
-        Self::Claude3_5Haiku
-    }
-
     pub fn from_id(id: &str) -> anyhow::Result<Self> {
         if id.starts_with("claude-3-5-sonnet-v2") {
             Ok(Self::Claude3_5SonnetV2)

crates/collab/src/api/billing.rs

@@ -449,29 +449,6 @@ async fn manage_billing_subscription(
             let stripe_subscription =
                 Subscription::retrieve(&stripe_client, &subscription_id, &[]).await?;
 
-            let is_on_zed_pro_trial = stripe_subscription.status == SubscriptionStatus::Trialing
-                && stripe_subscription.items.data.iter().any(|item| {
-                    item.price
-                        .as_ref()
-                        .map_or(false, |price| price.id == zed_pro_price_id)
-                });
-            if is_on_zed_pro_trial {
-                // If the user is already on a Zed Pro trial and wants to upgrade to Pro, we just need to end their trial early.
-                Subscription::update(
-                    &stripe_client,
-                    &stripe_subscription.id,
-                    stripe::UpdateSubscription {
-                        trial_end: Some(stripe::Scheduled::now()),
-                        ..Default::default()
-                    },
-                )
-                .await?;
-
-                return Ok(Json(ManageBillingSubscriptionResponse {
-                    billing_portal_session_url: None,
-                }));
-            }
-
             let subscription_item_to_update = stripe_subscription
                 .items
                 .data
@@ -479,7 +456,10 @@ async fn manage_billing_subscription(
                 .find_map(|item| {
                     let price = item.price.as_ref()?;
 
-                    if price.id == zed_free_price_id {
+                    if price.id == zed_free_price_id
+                        || (price.id == zed_pro_price_id
+                            && stripe_subscription.status == SubscriptionStatus::Trialing)
+                    {
                         Some(item.id.clone())
                     } else {
                         None

crates/collab/src/tests/integration_tests.rs

@@ -5091,7 +5091,6 @@ async fn test_project_search(
                 false,
                 Default::default(),
                 Default::default(),
-                false,
                 None,
             )
             .unwrap(),

crates/collab/src/tests/random_project_collaboration_tests.rs

@@ -882,7 +882,6 @@ impl RandomizedTest for ProjectCollaborationTest {
                             false,
                             Default::default(),
                             Default::default(),
-                            false,
                             None,
                         )
                         .unwrap(),

crates/collab_ui/src/chat_panel/message_editor.rs

@@ -37,7 +37,6 @@ static MENTIONS_SEARCH: LazyLock<SearchQuery> = LazyLock::new(|| {
         false,
         Default::default(),
         Default::default(),
-        false,
         None,
     )
     .unwrap()

crates/collab_ui/src/collab_ui.rs

@@ -66,6 +66,5 @@ fn notification_window_options(
         app_id: Some(app_id.to_owned()),
         window_min_size: None,
         window_decorations: Some(WindowDecorations::Client),
-        ..Default::default()
     }
 }

crates/copilot/src/copilot_chat.rs

@@ -61,10 +61,6 @@ pub enum Model {
 }
 
 impl Model {
-    pub fn default_fast() -> Self {
-        Self::Claude3_7Sonnet
-    }
-
     pub fn uses_streaming(&self) -> bool {
         match self {
             Self::Gpt4o

crates/deepseek/src/deepseek.rs

@@ -64,10 +64,6 @@ pub enum Model {
 }
 
 impl Model {
-    pub fn default_fast() -> Self {
-        Model::Chat
-    }
-
     pub fn from_id(id: &str) -> Result<Self> {
         match id {
             "deepseek-chat" => Ok(Self::Chat),

crates/editor/src/code_context_menus.rs

@@ -777,34 +777,11 @@ pub struct AvailableCodeAction {
 
 #[derive(Clone)]
 pub struct CodeActionContents {
-    tasks: Option<Rc<ResolvedTasks>>,
-    actions: Option<Rc<[AvailableCodeAction]>>,
+    pub tasks: Option<Rc<ResolvedTasks>>,
+    pub actions: Option<Rc<[AvailableCodeAction]>>,
 }
 
 impl CodeActionContents {
-    pub fn new(
-        mut tasks: Option<ResolvedTasks>,
-        actions: Option<Rc<[AvailableCodeAction]>>,
-        cx: &App,
-    ) -> Self {
-        if !cx.has_flag::<Debugger>() {
-            if let Some(tasks) = &mut tasks {
-                tasks
-                    .templates
-                    .retain(|(_, task)| !matches!(task.task_type(), task::TaskType::Debug(_)));
-            }
-        }
-
-        Self {
-            tasks: tasks.map(Rc::new),
-            actions,
-        }
-    }
-
-    pub fn tasks(&self) -> Option<&ResolvedTasks> {
-        self.tasks.as_deref()
-    }
-
     fn len(&self) -> usize {
         match (&self.tasks, &self.actions) {
             (Some(tasks), Some(actions)) => actions.len() + tasks.templates.len(),
@@ -1012,6 +989,17 @@ impl CodeActionsMenu {
                     .iter()
                     .skip(range.start)
                     .take(range.end - range.start)
+                    .filter(|action| {
+                        if action
+                            .as_task()
+                            .map(|task| matches!(task.task_type(), task::TaskType::Debug(_)))
+                            .unwrap_or(false)
+                        {
+                            cx.has_flag::<Debugger>()
+                        } else {
+                            true
+                        }
+                    })
                     .enumerate()
                     .map(|(ix, action)| {
                         let item_ix = range.start + ix;

crates/editor/src/editor.rs

@@ -215,7 +215,6 @@ const MAX_SELECTION_HISTORY_LEN: usize = 1024;
 pub(crate) const CURSORS_VISIBLE_FOR: Duration = Duration::from_millis(2000);
 #[doc(hidden)]
 pub const CODE_ACTIONS_DEBOUNCE_TIMEOUT: Duration = Duration::from_millis(250);
-const SELECTION_HIGHLIGHT_DEBOUNCE_TIMEOUT: Duration = Duration::from_millis(100);
 
 pub(crate) const CODE_ACTION_TIMEOUT: Duration = Duration::from_secs(5);
 pub(crate) const FORMAT_TIMEOUT: Duration = Duration::from_secs(5);
@@ -812,8 +811,7 @@ pub struct Editor {
     next_completion_id: CompletionId,
     available_code_actions: Option<(Location, Rc<[AvailableCodeAction]>)>,
     code_actions_task: Option<Task<Result<()>>>,
-    quick_selection_highlight_task: Option<(Range<Anchor>, Task<()>)>,
-    debounced_selection_highlight_task: Option<(Range<Anchor>, Task<()>)>,
+    selection_highlight_task: Option<Task<()>>,
     document_highlights_task: Option<Task<()>>,
     linked_editing_range_task: Option<Task<Option<()>>>,
     linked_edit_ranges: linked_editing_ranges::LinkedEditingRanges,
@@ -1592,8 +1590,7 @@ impl Editor {
             code_action_providers,
             available_code_actions: Default::default(),
             code_actions_task: Default::default(),
-            quick_selection_highlight_task: Default::default(),
-            debounced_selection_highlight_task: Default::default(),
+            selection_highlight_task: Default::default(),
             document_highlights_task: Default::default(),
             linked_editing_range_task: Default::default(),
             pending_rename: Default::default(),
@@ -1723,7 +1720,6 @@ impl Editor {
                                 new_anchor.offset,
                             );
                         });
-                        editor.hide_signature_help(cx, SignatureHelpHiddenBy::Escape);
                     }
                 }
                 EditorEvent::Edited { .. } => {
@@ -5017,15 +5013,15 @@ impl Editor {
                             None => None,
                         };
                         let resolved_tasks =
-                            tasks
-                                .zip(task_context)
-                                .map(|(tasks, task_context)| ResolvedTasks {
+                            tasks.zip(task_context).map(|(tasks, task_context)| {
+                                Rc::new(ResolvedTasks {
                                     templates: tasks.resolve(&task_context).collect(),
                                     position: snapshot.buffer_snapshot.anchor_before(Point::new(
                                         multibuffer_point.row,
                                         tasks.column,
                                     )),
-                                });
+                                })
+                            });
                         let spawn_straight_away = resolved_tasks.as_ref().map_or(false, |tasks| {
                             tasks
                                 .templates
@@ -5046,11 +5042,10 @@ impl Editor {
                             *editor.context_menu.borrow_mut() =
                                 Some(CodeContextMenu::CodeActions(CodeActionsMenu {
                                     buffer,
-                                    actions: CodeActionContents::new(
-                                        resolved_tasks,
-                                        code_actions,
-                                        cx,
-                                    ),
+                                    actions: CodeActionContents {
+                                        tasks: resolved_tasks,
+                                        actions: code_actions,
+                                    },
                                     selected_item: Default::default(),
                                     scroll_handle: UniformListScrollHandle::default(),
                                     deployed_from_indicator,
@@ -5479,169 +5474,111 @@ impl Editor {
         None
     }
 
-    fn prepare_highlight_query_from_selection(
+    pub fn refresh_selected_text_highlights(
         &mut self,
+        window: &mut Window,
         cx: &mut Context<Editor>,
-    ) -> Option<(String, Range<Anchor>)> {
+    ) {
         if matches!(self.mode, EditorMode::SingleLine { .. }) {
-            return None;
+            return;
         }
+        self.selection_highlight_task.take();
         if !EditorSettings::get_global(cx).selection_highlight {
-            return None;
+            self.clear_background_highlights::<SelectedTextHighlight>(cx);
+            return;
         }
         if self.selections.count() != 1 || self.selections.line_mode {
-            return None;
+            self.clear_background_highlights::<SelectedTextHighlight>(cx);
+            return;
         }
         let selection = self.selections.newest::<Point>(cx);
         if selection.is_empty() || selection.start.row != selection.end.row {
-            return None;
+            self.clear_background_highlights::<SelectedTextHighlight>(cx);
+            return;
         }
-        let multi_buffer_snapshot = self.buffer().read(cx).snapshot(cx);
-        let selection_anchor_range = selection.range().to_anchors(&multi_buffer_snapshot);
-        let query = multi_buffer_snapshot
-            .text_for_range(selection_anchor_range.clone())
-            .collect::<String>();
-        if query.trim().is_empty() {
-            return None;
-        }
-        Some((query, selection_anchor_range))
-    }
-
-    fn update_selection_occurrence_highlights(
-        &mut self,
-        query_text: String,
-        query_range: Range<Anchor>,
-        multi_buffer_range_to_query: Range<Point>,
-        use_debounce: bool,
-        window: &mut Window,
-        cx: &mut Context<Editor>,
-    ) -> Task<()> {
-        let multi_buffer_snapshot = self.buffer().read(cx).snapshot(cx);
-        cx.spawn_in(window, async move |editor, cx| {
-            if use_debounce {
-                cx.background_executor()
-                    .timer(SELECTION_HIGHLIGHT_DEBOUNCE_TIMEOUT)
-                    .await;
-            }
-            let match_task = cx.background_spawn(async move {
-                let buffer_ranges = multi_buffer_snapshot
-                    .range_to_buffer_ranges(multi_buffer_range_to_query)
-                    .into_iter()
-                    .filter(|(_, excerpt_visible_range, _)| !excerpt_visible_range.is_empty());
-                let mut match_ranges = Vec::new();
-                for (buffer_snapshot, search_range, excerpt_id) in buffer_ranges {
-                    match_ranges.extend(
-                        project::search::SearchQuery::text(
-                            query_text.clone(),
-                            false,
-                            false,
-                            false,
-                            Default::default(),
-                            Default::default(),
-                            false,
-                            None,
-                        )
-                        .unwrap()
-                        .search(&buffer_snapshot, Some(search_range.clone()))
-                        .await
-                        .into_iter()
-                        .filter_map(|match_range| {
-                            let match_start = buffer_snapshot
-                                .anchor_after(search_range.start + match_range.start);
-                            let match_end =
-                                buffer_snapshot.anchor_before(search_range.start + match_range.end);
-                            let match_anchor_range = Anchor::range_in_buffer(
-                                excerpt_id,
-                                buffer_snapshot.remote_id(),
-                                match_start..match_end,
-                            );
-                            (match_anchor_range != query_range).then_some(match_anchor_range)
-                        }),
-                    );
-                }
-                match_ranges
-            });
-            let match_ranges = match_task.await;
+        let debounce = EditorSettings::get_global(cx).selection_highlight_debounce;
+        self.selection_highlight_task = Some(cx.spawn_in(window, async move |editor, cx| {
+            cx.background_executor()
+                .timer(Duration::from_millis(debounce))
+                .await;
+            let Some(Some(matches_task)) = editor
+                .update_in(cx, |editor, _, cx| {
+                    if editor.selections.count() != 1 || editor.selections.line_mode {
+                        editor.clear_background_highlights::<SelectedTextHighlight>(cx);
+                        return None;
+                    }
+                    let selection = editor.selections.newest::<Point>(cx);
+                    if selection.is_empty() || selection.start.row != selection.end.row {
+                        editor.clear_background_highlights::<SelectedTextHighlight>(cx);
+                        return None;
+                    }
+                    let buffer = editor.buffer().read(cx).snapshot(cx);
+                    let query = buffer.text_for_range(selection.range()).collect::<String>();
+                    if query.trim().is_empty() {
+                        editor.clear_background_highlights::<SelectedTextHighlight>(cx);
+                        return None;
+                    }
+                    Some(cx.background_spawn(async move {
+                        let mut ranges = Vec::new();
+                        let selection_anchors = selection.range().to_anchors(&buffer);
+                        for range in [buffer.anchor_before(0)..buffer.anchor_after(buffer.len())] {
+                            for (search_buffer, search_range, excerpt_id) in
+                                buffer.range_to_buffer_ranges(range)
+                            {
+                                ranges.extend(
+                                    project::search::SearchQuery::text(
+                                        query.clone(),
+                                        false,
+                                        false,
+                                        false,
+                                        Default::default(),
+                                        Default::default(),
+                                        None,
+                                    )
+                                    .unwrap()
+                                    .search(search_buffer, Some(search_range.clone()))
+                                    .await
+                                    .into_iter()
+                                    .filter_map(
+                                        |match_range| {
+                                            let start = search_buffer.anchor_after(
+                                                search_range.start + match_range.start,
+                                            );
+                                            let end = search_buffer.anchor_before(
+                                                search_range.start + match_range.end,
+                                            );
+                                            let range = Anchor::range_in_buffer(
+                                                excerpt_id,
+                                                search_buffer.remote_id(),
+                                                start..end,
+                                            );
+                                            (range != selection_anchors).then_some(range)
+                                        },
+                                    ),
+                                );
+                            }
+                        }
+                        ranges
+                    }))
+                })
+                .log_err()
+            else {
+                return;
+            };
+            let matches = matches_task.await;
             editor
                 .update_in(cx, |editor, _, cx| {
                     editor.clear_background_highlights::<SelectedTextHighlight>(cx);
-                    if !match_ranges.is_empty() {
+                    if !matches.is_empty() {
                         editor.highlight_background::<SelectedTextHighlight>(
-                            &match_ranges,
+                            &matches,
                             |theme| theme.editor_document_highlight_bracket_background,
                             cx,
                         )
                     }
                 })
                 .log_err();
-        })
-    }
-
-    fn refresh_selected_text_highlights(&mut self, window: &mut Window, cx: &mut Context<Editor>) {
-        let Some((query_text, query_range)) = self.prepare_highlight_query_from_selection(cx)
-        else {
-            self.clear_background_highlights::<SelectedTextHighlight>(cx);
-            self.quick_selection_highlight_task.take();
-            self.debounced_selection_highlight_task.take();
-            return;
-        };
-        let multi_buffer_snapshot = self.buffer().read(cx).snapshot(cx);
-        if self
-            .quick_selection_highlight_task
-            .as_ref()
-            .map_or(true, |(prev_anchor_range, _)| {
-                prev_anchor_range != &query_range
-            })
-        {
-            let multi_buffer_visible_start = self
-                .scroll_manager
-                .anchor()
-                .anchor
-                .to_point(&multi_buffer_snapshot);
-            let multi_buffer_visible_end = multi_buffer_snapshot.clip_point(
-                multi_buffer_visible_start
-                    + Point::new(self.visible_line_count().unwrap_or(0.).ceil() as u32, 0),
-                Bias::Left,
-            );
-            let multi_buffer_visible_range = multi_buffer_visible_start..multi_buffer_visible_end;
-            self.quick_selection_highlight_task = Some((
-                query_range.clone(),
-                self.update_selection_occurrence_highlights(
-                    query_text.clone(),
-                    query_range.clone(),
-                    multi_buffer_visible_range,
-                    false,
-                    window,
-                    cx,
-                ),
-            ));
-        }
-        if self
-            .debounced_selection_highlight_task
-            .as_ref()
-            .map_or(true, |(prev_anchor_range, _)| {
-                prev_anchor_range != &query_range
-            })
-        {
-            let multi_buffer_start = multi_buffer_snapshot
-                .anchor_before(0)
-                .to_point(&multi_buffer_snapshot);
-            let multi_buffer_end = multi_buffer_snapshot
-                .anchor_after(multi_buffer_snapshot.len())
-                .to_point(&multi_buffer_snapshot);
-            let multi_buffer_full_range = multi_buffer_start..multi_buffer_end;
-            self.debounced_selection_highlight_task = Some((
-                query_range.clone(),
-                self.update_selection_occurrence_highlights(
-                    query_text,
-                    query_range,
-                    multi_buffer_full_range,
-                    true,
-                    window,
-                    cx,
-                ),
-            ));
-        }
+        }));
     }
 
     pub fn refresh_inline_completion(
@@ -10218,19 +10155,11 @@ impl Editor {
                                 ..Point::new(row.0, buffer.line_len(row)),
                         );
                         for row in start.row + 1..=end.row {
-                            let mut line_len = buffer.line_len(MultiBufferRow(row));
-                            if row == end.row {
-                                line_len = end.column;
-                            }
-                            if line_len == 0 {
-                                trimmed_selections
-                                    .push(Point::new(row, 0)..Point::new(row, line_len));
-                                continue;
-                            }
                             let row_indent_size = buffer.indent_size_for_line(MultiBufferRow(row));
                             if row_indent_size.len >= first_indent.len {
                                 trimmed_selections.push(
-                                    Point::new(row, first_indent.len)..Point::new(row, line_len),
+                                    Point::new(row, first_indent.len)
+                                        ..Point::new(row, buffer.line_len(MultiBufferRow(row))),
                                 );
                             } else {
                                 trimmed_selections.clear();

crates/editor/src/editor_settings.rs

@@ -10,6 +10,7 @@ pub struct EditorSettings {
     pub cursor_shape: Option<CursorShape>,
     pub current_line_highlight: CurrentLineHighlight,
     pub selection_highlight: bool,
+    pub selection_highlight_debounce: u64,
     pub lsp_highlight_debounce: u64,
     pub hover_popover_enabled: bool,
     pub hover_popover_delay: u64,
@@ -262,6 +263,10 @@ pub struct EditorSettingsContent {
     ///
     /// Default: true
     pub selection_highlight: Option<bool>,
+    /// The debounce delay before querying highlights based on the selected text.
+    ///
+    /// Default: 75
+    pub selection_highlight_debounce: Option<u64>,
     /// The debounce delay before querying highlights from the language
     /// server based on the current cursor location.
     ///

crates/editor/src/editor_tests.rs

@@ -5121,36 +5121,6 @@ if is_entire_line {
         ),
         "When selecting past the indent, nothing is trimmed"
     );
-
-    cx.set_state(
-        r#"            «for selection in selections.iter() {
-            let mut start = selection.start;
-
-            let mut end = selection.end;
-            let is_entire_line = selection.is_empty();
-            if is_entire_line {
-                start = Point::new(start.row, 0);
-ˇ»                end = cmp::min(max_point, Point::new(end.row + 1, 0));
-            }
-        "#,
-    );
-    cx.update_editor(|e, window, cx| e.copy_and_trim(&CopyAndTrim, window, cx));
-    assert_eq!(
-        cx.read_from_clipboard()
-            .and_then(|item| item.text().as_deref().map(str::to_string)),
-        Some(
-            "for selection in selections.iter() {
-let mut start = selection.start;
-
-let mut end = selection.end;
-let is_entire_line = selection.is_empty();
-if is_entire_line {
-    start = Point::new(start.row, 0);
-"
-            .to_string()
-        ),
-        "Copying with stripping should ignore empty lines"
-    );
 }
 
 #[gpui::test]

crates/editor/src/element.rs

@@ -2092,7 +2092,8 @@ impl EditorElement {
                 })) = editor.context_menu.borrow().as_ref()
                 {
                     actions
-                        .tasks()
+                        .tasks
+                        .as_ref()
                         .map(|tasks| tasks.position.to_display_point(snapshot).row())
                         .or(*deployed_from_indicator)
                 } else {

crates/eval/Cargo.toml

@@ -36,6 +36,7 @@ prompt_store.workspace = true
 release_channel.workspace = true
 reqwest_client.workspace = true
 serde.workspace = true
+serde_json.workspace = true
 settings.workspace = true
 shellexpand.workspace = true
 telemetry.workspace = true
@@ -43,7 +44,6 @@ toml.workspace = true
 unindent.workspace = true
 util.workspace = true
 uuid = { version = "1.6", features = ["v4"] }
-workspace-hack.workspace = true
 
 [[bin]]
 name = "eval"

crates/eval/examples/find_and_replace_diff_card/base.toml

@@ -1,3 +1,3 @@
 url = "https://github.com/zed-industries/zed.git"
-revision = "03ecb88fe30794873f191ddb728f597935b3101c"
+revision = "38fcadf9481d018543c65f36ac3bafeba190179b"
 language_extension = "rs"

crates/eval/examples/find_and_replace_diff_card/thread_criteria.md

@@ -1,3 +1,3 @@
-1. The first tool call should be to path search including "find_replace_file_tool.rs" in the string. (*Not* grep, for example, or reading the file based on a guess at the path.) This is because we gave the model a filename and it needs to turn that into a real path.
+1. The first tool call should be to path search including "find_replace_file_tool.rs" in the string. (*Not* regex_search, for example, or reading the file based on a guess at the path.) This is because we gave the model a filename and it needs to turn that into a real path.
 2. After obtaining the correct path of "zed/crates/assistant_tools/src/find_replace_file_tool.rs", it should read the contents of that path.
 3. When trying to find information about the Render trait, it should *not* begin with a path search, because it doesn't yet have any information on what path the Render trait might be in.

crates/eval/src/eval.rs

@@ -11,10 +11,12 @@ use clap::Parser;
 use extension::ExtensionHostProxy;
 use futures::{StreamExt, future};
 use gpui::http_client::{Uri, read_proxy_from_env};
-use gpui::{App, AppContext, Application, AsyncApp, Entity, SemanticVersion, UpdateGlobal};
+use gpui::{App, AppContext, Application, AsyncApp, Entity, SemanticVersion, Task, UpdateGlobal};
 use gpui_tokio::Tokio;
 use language::LanguageRegistry;
-use language_model::{ConfiguredModel, LanguageModel, LanguageModelRegistry};
+use language_model::{
+    AuthenticateError, LanguageModel, LanguageModelProviderId, LanguageModelRegistry,
+};
 use node_runtime::{NodeBinaryOptions, NodeRuntime};
 use project::Project;
 use project::project_settings::ProjectSettings;
@@ -33,30 +35,40 @@ pub const RUNS_DIR: &str = "./crates/eval/runs";
 #[derive(Parser, Debug)]
 #[command(name = "eval", disable_version_flag = true)]
 struct Args {
-    /// Runs all examples that contain these substrings. If unspecified, all examples are run.
-    #[arg(value_name = "EXAMPLE_SUBSTRING")]
-    examples: Vec<String>,
+    /// Optional cohort ID to group runs together (useful for GitHub Actions)
+    #[arg(long)]
+    cohort_id: Option<String>,
+
     /// Model to use (default: "claude-3-7-sonnet-latest")
     #[arg(long, default_value = "claude-3-7-sonnet-latest")]
     model: String,
+
     #[arg(long, value_delimiter = ',')]
     languages: Option<Vec<String>>,
+
     /// How many times to run each example. Note that this is currently not very efficient as N
     /// worktrees will be created for the examples.
     #[arg(long, default_value = "1")]
     repetitions: u32,
+
     /// How many times to run the judge on each example run.
     #[arg(long, default_value = "3")]
     judge_repetitions: u32,
+
     /// Maximum number of examples to run concurrently.
     #[arg(long, default_value = "10")]
     concurrency: usize,
+
+    /// Runs all examples that contain these substrings. If unspecified, all examples are run.
+    #[arg(value_name = "EXAMPLE_SUBSTRING")]
+    examples: Vec<String>,
 }
 
 fn main() {
     env_logger::init();
 
     let args = Args::parse();
+
     let all_available_examples = list_all_examples().unwrap();
     let languages = args.languages.unwrap_or_else(|| vec!["rs".to_string()]);
 
@@ -92,25 +104,18 @@ fn main() {
             .telemetry()
             .start(system_id, installation_id, session_id, cx);
 
-        let model_registry = LanguageModelRegistry::read_global(cx);
-        let model = find_model("claude-3-7-sonnet-latest", model_registry, cx).unwrap();
-        let model_provider_id = model.provider_id();
-        let model_provider = model_registry.provider(&model_provider_id).unwrap();
+        let model = find_model("claude-3-7-sonnet-latest", cx).unwrap();
 
         LanguageModelRegistry::global(cx).update(cx, |registry, cx| {
-            registry.set_default_model(
-                Some(ConfiguredModel {
-                    provider: model_provider.clone(),
-                    model: model.clone(),
-                }),
-                cx,
-            );
+            registry.set_default_model(Some(model.clone()), cx);
         });
 
-        let authenticate_task = model_provider.authenticate(cx);
+        let model_provider_id = model.provider_id();
+
+        let authenticate = authenticate_model_provider(model_provider_id.clone(), cx);
 
         cx.spawn(async move |cx| {
-            authenticate_task.await.unwrap();
+            authenticate.await.unwrap();
 
             std::fs::create_dir_all(REPOS_DIR)?;
             std::fs::create_dir_all(WORKTREES_DIR)?;
@@ -238,14 +243,17 @@ fn main() {
 
             let judge_repetitions = args.judge_repetitions;
             let concurrency = args.concurrency;
+            let cohort_id = args.cohort_id.clone();
 
             let tasks = examples.iter().map(|example| {
                 let app_state = app_state.clone();
                 let model = model.clone();
                 let example = example.clone();
+                let cohort_id = cohort_id.clone();
                 cx.spawn(async move |cx| {
                     let result =
-                        run_example(&example, model, app_state, judge_repetitions, cx).await;
+                        run_example(&example, model, app_state, judge_repetitions, cohort_id, cx)
+                            .await;
                     (result, example)
                 })
             });
@@ -356,14 +364,23 @@ async fn run_example(
     model: Arc<dyn LanguageModel>,
     app_state: Arc<AgentAppState>,
     judge_repetitions: u32,
+    optional_cohort_id: Option<String>,
     cx: &mut AsyncApp,
 ) -> Result<Vec<Result<JudgeOutput>>> {
     let run_output = cx
         .update(|cx| example.run(model.clone(), app_state.clone(), cx))?
         .await?;
 
-    let judge_tasks = (0..judge_repetitions)
-        .map(|round| run_judge_repetition(example.clone(), model.clone(), &run_output, round, cx));
+    let judge_tasks = (0..judge_repetitions).map(|round| {
+        run_judge_repetition(
+            example.clone(),
+            model.clone(),
+            &run_output,
+            round,
+            optional_cohort_id.clone(),
+            cx,
+        )
+    });
 
     let results = future::join_all(judge_tasks).await;
 
@@ -483,7 +500,6 @@ pub fn init(cx: &mut App) -> Arc<AgentAppState> {
     languages::init(languages.clone(), node_runtime.clone(), cx);
     assistant_tools::init(client.http_client().clone(), cx);
     context_server::init(cx);
-    prompt_store::init(cx);
     let stdout_is_a_pty = false;
     let prompt_builder = PromptBuilder::load(fs.clone(), stdout_is_a_pty, cx);
     agent::init(fs.clone(), client.clone(), prompt_builder.clone(), cx);
@@ -503,11 +519,8 @@ pub fn init(cx: &mut App) -> Arc<AgentAppState> {
     })
 }
 
-pub fn find_model(
-    model_name: &str,
-    model_registry: &LanguageModelRegistry,
-    cx: &App,
-) -> anyhow::Result<Arc<dyn LanguageModel>> {
+pub fn find_model(model_name: &str, cx: &App) -> anyhow::Result<Arc<dyn LanguageModel>> {
+    let model_registry = LanguageModelRegistry::read_global(cx);
     let model = model_registry
         .available_models(cx)
         .find(|model| model.id().0 == model_name);
@@ -527,6 +540,15 @@ pub fn find_model(
     Ok(model)
 }
 
+pub fn authenticate_model_provider(
+    provider_id: LanguageModelProviderId,
+    cx: &mut App,
+) -> Task<std::result::Result<(), AuthenticateError>> {
+    let model_registry = LanguageModelRegistry::read_global(cx);
+    let model_provider = model_registry.provider(&provider_id).unwrap();
+    model_provider.authenticate(cx)
+}
+
 pub async fn get_current_commit_id(repo_path: &Path) -> Option<String> {
     (run_git(repo_path, &["rev-parse", "HEAD"]).await).ok()
 }
@@ -542,16 +564,22 @@ async fn run_judge_repetition(
     model: Arc<dyn LanguageModel>,
     run_output: &RunOutput,
     round: u32,
+    optional_cohort_id: Option<String>,
     cx: &AsyncApp,
 ) -> Result<JudgeOutput> {
     let judge_result = example.judge(model.clone(), &run_output, round, cx).await;
 
     if let Ok(judge_output) = &judge_result {
-        let cohort_id = example
-            .run_directory_path
-            .file_name()
-            .map(|name| name.to_string_lossy().to_string())
-            .unwrap_or(chrono::Local::now().format("%Y-%m-%d_%H-%M-%S").to_string());
+        let cohort_id = if let Some(id) = optional_cohort_id.clone() {
+            id
+        } else {
+            let fallback_id = example
+                .run_directory_path
+                .file_name()
+                .map(|name| name.to_string_lossy().to_string())
+                .unwrap_or(chrono::Local::now().format("%Y-%m-%d_%H-%M-%S").to_string());
+            fallback_id
+        };
 
         let path = std::path::Path::new(".");
         let commit_id = get_current_commit_id(path).await.unwrap_or_default();

crates/eval/src/example.rs

@@ -1,4 +1,4 @@
-use agent::{ThreadEvent, ThreadStore};
+use agent::{RequestKind, ThreadEvent, ThreadStore};
 use anyhow::{Context as _, Result, anyhow};
 use assistant_tool::ToolWorkingSet;
 use client::proto::LspWorkProgress;
@@ -8,12 +8,12 @@ use futures::channel::mpsc;
 use futures::{FutureExt, StreamExt as _, select_biased};
 use gpui::{App, AppContext as _, AsyncApp, Entity, Task};
 use handlebars::Handlebars;
-use language::{Buffer, DiagnosticSeverity, OffsetRangeExt};
+use language::{DiagnosticSeverity, OffsetRangeExt};
 use language_model::{
     LanguageModel, LanguageModelCompletionEvent, LanguageModelRequest, LanguageModelRequestMessage,
     MessageContent, Role, StopReason, TokenUsage,
 };
-use project::{Project, ProjectPath};
+use project::{LspStore, Project, ProjectPath};
 use serde::{Deserialize, Serialize};
 use std::cell::RefCell;
 use std::fmt::Write as _;
@@ -29,7 +29,6 @@ use std::{
 use unindent::Unindent as _;
 use util::ResultExt as _;
 use util::command::new_smol_command;
-use util::markdown::MarkdownString;
 use util::serde::default_true;
 
 use crate::AgentAppState;
@@ -271,7 +270,7 @@ impl Example {
                 })?
                 .await;
 
-            let lsp = if this.base.require_lsp {
+            let lsp_open_handle_and_store = if this.base.require_lsp {
                 let language_extension = this.base.language_extension.as_deref().context(
                     "language_extension field is required in base.toml when `require_lsp == true`",
                 )?;
@@ -301,13 +300,39 @@ impl Example {
 
                 let language_file_buffer = open_language_file_buffer_task.await?;
 
-                let lsp_open_handle = project.update(cx, |project, cx| {
-                    project.register_buffer_with_language_servers(&language_file_buffer, cx)
+                let (lsp_open_handle, lsp_store) = project.update(cx, |project, cx| {
+                    (
+                        project.register_buffer_with_language_servers(&language_file_buffer, cx),
+                        project.lsp_store().clone(),
+                    )
                 })?;
 
-                wait_for_lang_server(&project, &language_file_buffer, this.log_prefix.clone(), cx).await?;
+                // TODO: remove this once the diagnostics tool waits for new diagnostics
+                cx.background_executor().timer(Duration::new(5, 0)).await;
+                wait_for_lang_server(&lsp_store, this.log_prefix.clone(), cx).await?;
 
-                Some((lsp_open_handle, language_file_buffer))
+                lsp_store.update(cx, |lsp_store, cx| {
+                    lsp_open_handle.update(cx, |buffer, cx| {
+                        buffer.update(cx, |buffer, cx| {
+                            let has_language_server = lsp_store
+                                .language_servers_for_local_buffer(buffer, cx)
+                                .next()
+                                .is_some();
+                            if has_language_server {
+                                Ok(())
+                            } else {
+                                Err(anyhow!(
+                                    "`{:?}` was opened to cause the language server to start, \
+                                    but no language servers are registered for its buffer. \
+                                    Set `require_lsp = false` in `base.toml` to skip this.",
+                                    language_file
+                                ))
+                            }
+                        })
+                    })
+                })??;
+
+                Some((lsp_open_handle, lsp_store))
             } else {
                 None
             };
@@ -321,7 +346,7 @@ impl Example {
                 return Err(anyhow!("Setup only mode"));
             }
 
-            let thread_store = thread_store.await?;
+            let thread_store = thread_store.await;
             let thread =
                 thread_store.update(cx, |thread_store, cx| thread_store.create_thread(cx))?;
             let last_request = Rc::new(RefCell::new(None));
@@ -446,15 +471,15 @@ impl Example {
             thread.update(cx, |thread, cx| {
                 let context = vec![];
                 thread.insert_user_message(this.prompt.clone(), context, None, cx);
-                thread.send_to_model(model, cx);
+                thread.send_to_model(model, RequestKind::Chat, cx);
             })?;
 
             event_handler_task.await?;
 
             println!("{}Stopped", this.log_prefix);
 
-            if let Some((_, language_file_buffer)) = lsp.as_ref() {
-                wait_for_lang_server(&project, &language_file_buffer, this.log_prefix.clone(), cx).await?;
+            if let Some((_, lsp_store)) = lsp_open_handle_and_store.as_ref() {
+                wait_for_lang_server(lsp_store, this.log_prefix.clone(), cx).await?;
             }
 
             println!("{}Getting repository diff", this.log_prefix);
@@ -478,7 +503,7 @@ impl Example {
             };
 
             drop(subscription);
-            drop(lsp);
+            drop(lsp_open_handle_and_store);
 
             if let Some(diagnostics_before) = &diagnostics_before {
                 fs::write(example_output_dir.join("diagnostics_before.txt"), diagnostics_before)?;
@@ -515,7 +540,7 @@ impl Example {
         judge_number: u32,
         cx: &AsyncApp,
     ) -> Result<(String, JudgeResponse)> {
-        let judge_diff_prompt = include_str!("judge_diff_prompt.hbs");
+        let judge_diff_prompt = include_str!("judge_diff_prompt_2.hbs");
         let judge_diff_prompt_name = "judge_diff_prompt";
         let mut hbs = Handlebars::new();
         hbs.register_template_string(judge_diff_prompt_name, judge_diff_prompt)?;
@@ -532,8 +557,6 @@ impl Example {
         )?;
 
         let request = LanguageModelRequest {
-            thread_id: None,
-            prompt_id: None,
             messages: vec![LanguageModelRequestMessage {
                 role: Role::User,
                 content: vec![MessageContent::Text(diff_prompt)],
@@ -578,8 +601,6 @@ impl Example {
             )?;
 
             let request = LanguageModelRequest {
-                thread_id: None,
-                prompt_id: None,
                 messages: vec![LanguageModelRequestMessage {
                     role: Role::User,
                     content: vec![MessageContent::Text(thread_prompt)],
@@ -648,42 +669,27 @@ impl Example {
 }
 
 fn wait_for_lang_server(
-    project: &Entity<Project>,
-    buffer: &Entity<Buffer>,
+    lsp_store: &Entity<LspStore>,
     log_prefix: String,
     cx: &mut AsyncApp,
 ) -> Task<Result<()>> {
+    if cx
+        .update(|cx| !has_pending_lang_server_work(lsp_store, cx))
+        .unwrap()
+        || std::env::var("ZED_EVAL_SKIP_LS_WAIT").is_ok()
+    {
+        return Task::ready(anyhow::Ok(()));
+    }
+
     println!("{}⏵ Waiting for language server", log_prefix);
 
     let (mut tx, mut rx) = mpsc::channel(1);
 
-    let lsp_store = project
-        .update(cx, |project, _| project.lsp_store())
-        .unwrap();
-
-    let has_lang_server = buffer
-        .update(cx, |buffer, cx| {
-            lsp_store.update(cx, |lsp_store, cx| {
-                lsp_store
-                    .language_servers_for_local_buffer(&buffer, cx)
-                    .next()
-                    .is_some()
-            })
-        })
-        .unwrap_or(false);
-
-    if has_lang_server {
-        project
-            .update(cx, |project, cx| project.save_buffer(buffer.clone(), cx))
-            .unwrap()
-            .detach();
-    }
-
-    let subscriptions =
-        [
-            cx.subscribe(&lsp_store, {
-                let log_prefix = log_prefix.clone();
-                move |_, event, _| match event {
+    let subscription =
+        cx.subscribe(&lsp_store, {
+            let log_prefix = log_prefix.clone();
+            move |lsp_store, event, cx| {
+                match event {
                     project::LspStoreEvent::LanguageServerUpdate {
                         message:
                             client::proto::update_language_server::Variant::WorkProgress(
@@ -696,23 +702,12 @@ fn wait_for_lang_server(
                     } => println!("{}⟲ {message}", log_prefix),
                     _ => {}
                 }
-            }),
-            cx.subscribe(&project, {
-                let buffer = buffer.clone();
-                move |project, event, cx| match event {
-                    project::Event::LanguageServerAdded(_, _, _) => {
-                        let buffer = buffer.clone();
-                        project
-                            .update(cx, |project, cx| project.save_buffer(buffer, cx))
-                            .detach();
-                    }
-                    project::Event::DiskBasedDiagnosticsFinished { .. } => {
-                        tx.try_send(()).ok();
-                    }
-                    _ => {}
+
+                if !has_pending_lang_server_work(&lsp_store, cx) {
+                    tx.try_send(()).ok();
                 }
-            }),
-        ];
+            }
+        });
 
     cx.spawn(async move |cx| {
         let timeout = cx.background_executor().timer(Duration::new(60 * 5, 0));
@@ -725,11 +720,18 @@ fn wait_for_lang_server(
                 Err(anyhow!("LSP wait timed out after 5 minutes"))
             }
         };
-        drop(subscriptions);
+        drop(subscription);
         result
     })
 }
 
+fn has_pending_lang_server_work(lsp_store: &Entity<LspStore>, cx: &App) -> bool {
+    lsp_store
+        .read(cx)
+        .language_server_statuses()
+        .any(|(_, status)| !status.pending_work.is_empty())
+}
+
 async fn query_lsp_diagnostics(
     project: Entity<Project>,
     cx: &mut AsyncApp,
@@ -873,7 +875,6 @@ impl RequestMarkdown {
     fn new(request: &LanguageModelRequest) -> Self {
         let mut tools = String::new();
         let mut messages = String::new();
-        let mut assistant_message_number: u32 = 1;
 
         // Print the tools
         if !request.tools.is_empty() {
@@ -882,8 +883,8 @@ impl RequestMarkdown {
                 write!(&mut tools, "{}\n\n", tool.description).unwrap();
                 write!(
                     &mut tools,
-                    "{}\n",
-                    MarkdownString::code_block("json", &format!("{:#}", tool.input_schema))
+                    "```json\n{}\n```\n\n",
+                    serde_json::to_string_pretty(&tool.input_schema).unwrap_or_default()
                 )
                 .unwrap();
             }
@@ -891,15 +892,14 @@ impl RequestMarkdown {
 
         // Print the messages
         for message in &request.messages {
-            match message.role {
-                Role::System => messages.push_str("# ⚙️ SYSTEM\n\n"),
-                Role::User => messages.push_str("# 👤 USER\n\n"),
-                Role::Assistant => {
-                    messages.push_str(&format!("# 🤖 ASSISTANT {assistant_message_number}\n\n"));
-                    assistant_message_number += 1;
-                }
+            let role_str = match message.role {
+                Role::User => "👤 USER",
+                Role::Assistant => "🤖 ASSISTANT",
+                Role::System => "⚙️ SYSTEM",
             };
 
+            messages.push_str(&format!("# {}\n\n", role_str));
+
             for content in &message.content {
                 match content {
                     MessageContent::Text(text) => {
@@ -909,39 +909,22 @@ impl RequestMarkdown {
                     MessageContent::Image(_) => {
                         messages.push_str("[IMAGE DATA]\n\n");
                     }
-                    MessageContent::Thinking { text, signature } => {
-                        messages.push_str("**Thinking**:\n\n");
-                        if let Some(sig) = signature {
-                            messages.push_str(&format!("Signature: {}\n\n", sig));
-                        }
-                        messages.push_str(text);
-                        messages.push_str("\n");
-                    }
-                    MessageContent::RedactedThinking(items) => {
-                        messages.push_str(&format!(
-                            "**Redacted Thinking**: {} item(s)\n\n",
-                            items.len()
-                        ));
-                    }
                     MessageContent::ToolUse(tool_use) => {
                         messages.push_str(&format!(
                             "**Tool Use**: {} (ID: {})\n",
                             tool_use.name, tool_use.id
                         ));
-                        messages.push_str(&format!(
-                            "{}\n",
-                            MarkdownString::code_block("json", &format!("{:#}", tool_use.input))
-                        ));
+                        messages.push_str(&format!("```json\n{}\n```\n\n", tool_use.input));
                     }
                     MessageContent::ToolResult(tool_result) => {
                         messages.push_str(&format!(
-                            "**Tool Result**: {} (ID: {})\n\n",
+                            "**Tool Result**: {} (ID: {})\n",
                             tool_result.tool_name, tool_result.tool_use_id
                         ));
                         if tool_result.is_error {
                             messages.push_str("**ERROR:**\n");
                         }
-                        messages.push_str(&format!("{}\n\n", tool_result.content));
+                        messages.push_str(&format!("```\n{}\n```\n\n", tool_result.content));
                     }
                 }
             }
@@ -977,7 +960,7 @@ fn response_events_to_markdown(
             Ok(LanguageModelCompletionEvent::Text(text)) => {
                 text_buffer.push_str(text);
             }
-            Ok(LanguageModelCompletionEvent::Thinking { text, .. }) => {
+            Ok(LanguageModelCompletionEvent::Thinking(text)) => {
                 thinking_buffer.push_str(text);
             }
             Ok(LanguageModelCompletionEvent::Stop(reason)) => {
@@ -990,10 +973,7 @@ fn response_events_to_markdown(
                     "**Tool Use**: {} (ID: {})\n",
                     tool_use.name, tool_use.id
                 ));
-                response.push_str(&format!(
-                    "{}\n",
-                    MarkdownString::code_block("json", &format!("{:#}", tool_use.input))
-                ));
+                response.push_str(&format!("```json\n{}\n```\n\n", tool_use.input));
             }
             Ok(
                 LanguageModelCompletionEvent::UsageUpdate(_)
@@ -1190,7 +1170,7 @@ mod test {
     const JUDGE_PROMPT_NAME: &str = "judge_prompt";
 
     fn templates() -> Handlebars<'static> {
-        let mut judge_prompt = include_str!("judge_diff_prompt.hbs").to_string();
+        let mut judge_prompt = include_str!("judge_diff_prompt_2.hbs").to_string();
         language::LineEnding::normalize(&mut judge_prompt);
         let mut handlebars = Handlebars::new();
         handlebars

crates/git_ui/src/commit_modal.rs

@@ -128,16 +128,9 @@ impl CommitModal {
             if let Some(force_mode) = force_mode {
                 match force_mode {
                     ForceMode::Amend => {
-                        if git_panel
-                            .active_repository
-                            .as_ref()
-                            .and_then(|repo| repo.read(cx).head_commit.as_ref())
-                            .is_some()
-                        {
-                            if !git_panel.amend_pending() {
-                                git_panel.set_amend_pending(true, cx);
-                                git_panel.load_last_commit_message_if_empty(cx);
-                            }
+                        if !git_panel.amend_pending() {
+                            git_panel.set_amend_pending(true, cx);
+                            git_panel.load_last_commit_message_if_empty(cx);
                         }
                     }
                     ForceMode::Commit => {
@@ -304,7 +297,8 @@ impl CommitModal {
             let is_amend_pending = git_panel.amend_pending();
             let has_previous_commit = active_repo
                 .as_ref()
-                .and_then(|repo| repo.read(cx).head_commit.as_ref())
+                .and_then(|repo| repo.read(cx).branch.as_ref())
+                .and_then(|branch| branch.most_recent_commit.as_ref())
                 .is_some();
             (
                 can_commit,
@@ -539,16 +533,6 @@ impl CommitModal {
     }
 
     fn amend(&mut self, _: &git::Amend, window: &mut Window, cx: &mut Context<Self>) {
-        if self
-            .git_panel
-            .read(cx)
-            .active_repository
-            .as_ref()
-            .and_then(|repo| repo.read(cx).head_commit.as_ref())
-            .is_none()
-        {
-            return;
-        }
         if !self.git_panel.read(cx).amend_pending() {
             self.git_panel.update(cx, |git_panel, cx| {
                 git_panel.set_amend_pending(true, cx);

crates/git_ui/src/git_panel.rs

@@ -1406,20 +1406,13 @@ impl GitPanel {
             .focus_handle(cx)
             .contains_focused(window, cx)
         {
-            if self
-                .active_repository
-                .as_ref()
-                .and_then(|repo| repo.read(cx).head_commit.as_ref())
-                .is_some()
-            {
-                if !self.amend_pending {
-                    self.set_amend_pending(true, cx);
-                    self.load_last_commit_message_if_empty(cx);
-                } else {
-                    telemetry::event!("Git Amended", source = "Git Panel");
-                    self.set_amend_pending(false, cx);
-                    self.commit_changes(CommitOptions { amend: true }, window, cx);
-                }
+            if !self.amend_pending {
+                self.set_amend_pending(true, cx);
+                self.load_last_commit_message_if_empty(cx);
+            } else {
+                telemetry::event!("Git Amended", source = "Git Panel");
+                self.set_amend_pending(false, cx);
+                self.commit_changes(CommitOptions { amend: true }, window, cx);
             }
         } else {
             cx.propagate();
@@ -1433,9 +1426,11 @@ impl GitPanel {
         let Some(active_repository) = self.active_repository.as_ref() else {
             return;
         };
-        let Some(recent_sha) = active_repository
-            .read(cx)
-            .head_commit
+        let Some(branch) = active_repository.read(cx).branch.as_ref() else {
+            return;
+        };
+        let Some(recent_sha) = branch
+            .most_recent_commit
             .as_ref()
             .map(|commit| commit.sha.to_string())
         else {
@@ -1744,8 +1739,6 @@ impl GitPanel {
                 const PROMPT: &str = include_str!("commit_message_prompt.txt");
 
                 let request = LanguageModelRequest {
-                    thread_id: None,
-                    prompt_id: None,
                     messages: vec![LanguageModelRequestMessage {
                         role: Role::User,
                         content: vec![content.into()],
@@ -2965,7 +2958,10 @@ impl GitPanel {
         let editor_is_long = self.commit_editor.update(cx, |editor, cx| {
             editor.max_point(cx).row().0 >= MAX_PANEL_EDITOR_LINES as u32
         });
-        let has_previous_commit = head_commit.is_some();
+        let has_previous_commit = branch
+            .as_ref()
+            .and_then(|branch| branch.most_recent_commit.as_ref())
+            .is_some();
 
         let footer = v_flex()
             .child(PanelRepoFooter::new(

crates/go_to_line/src/cursor_position.rs

@@ -99,7 +99,7 @@ impl CursorPosition {
                                 let mut last_selection = None::<Selection<Point>>;
                                 let snapshot = editor.buffer().read(cx).snapshot(cx);
                                 if snapshot.excerpts().count() > 0 {
-                                    for selection in editor.selections.all_adjusted(cx) {
+                                    for selection in editor.selections.all::<Point>(cx) {
                                         let selection_summary = snapshot
                                             .text_summary_for_range::<text::TextSummary, _>(
                                                 selection.start..selection.end,

crates/google_ai/src/google_ai.rs

@@ -412,10 +412,6 @@ pub enum Model {
 }
 
 impl Model {
-    pub fn default_fast() -> Model {
-        Model::Gemini15Flash
-    }
-
     pub fn id(&self) -> &str {
         match self {
             Model::Gemini15Pro => "gemini-1.5-pro",

crates/gpui/Cargo.toml

@@ -66,7 +66,7 @@ x11 = [
     "x11-clipboard",
     "filedescriptor",
     "open",
-    "scap",
+    "scap"
 ]
 
 
@@ -220,7 +220,6 @@ rand.workspace = true
 windows.workspace = true
 windows-core = "0.61"
 windows-numerics = "0.2"
-windows-registry = "0.5"
 
 [dev-dependencies]
 backtrace = "0.3"

crates/gpui/examples/input.rs

@@ -635,7 +635,7 @@ impl Render for InputExample {
                     .flex()
                     .flex_row()
                     .justify_between()
-                    .child(format!("Keyboard {}", cx.keyboard_layout().name()))
+                    .child(format!("Keyboard {}", cx.keyboard_layout()))
                     .child(
                         div()
                             .border_1()

crates/gpui/examples/pattern.rs

@@ -12,7 +12,7 @@ impl Render for PatternExample {
             .flex_col()
             .gap_3()
             .bg(rgb(0xffffff))
-            .size(px(600.0))  // This sets both width and height to 600px
+            .size(px(600.0))
             .justify_center()
             .items_center()
             .shadow_lg()
@@ -100,13 +100,10 @@ impl Render for PatternExample {
 
 fn main() {
     Application::new().run(|cx: &mut App| {
-        // Make window large enough to fit content with DevTools
-        // The main view will get (600px - 200px) = 400px width when DevTools are on
         let bounds = Bounds::centered(None, size(px(600.0), px(600.0)), cx);
         cx.open_window(
             WindowOptions {
                 window_bounds: Some(WindowBounds::Windowed(bounds)),
-                show_devtools: true, // Enable DevTools panel
                 ..Default::default()
             },
             |_window, cx| cx.new(|_cx| PatternExample),

crates/gpui/examples/window_positioning.rs

@@ -62,7 +62,6 @@ fn build_window_options(display_id: DisplayId, bounds: Bounds<Pixels>) -> Window
         app_id: None,
         window_min_size: None,
         window_decorations: None,
-        show_devtools: false,
     }
 }
 

crates/gpui/src/action.rs

@@ -394,10 +394,7 @@ macro_rules! action_with_deprecated_aliases {
     };
 }
 
-/// Registers the action and implements the Action trait for any struct that implements Clone,
-/// Default, PartialEq, serde_deserialize::Deserialize, and schemars::JsonSchema.
-///
-/// Similar to `impl_actions!`, but only handles one struct, and registers some deprecated aliases.
+/// Defines and registers a unit struct that can be used as an action, with some deprecated aliases.
 #[macro_export]
 macro_rules! impl_action_with_deprecated_aliases {
     ($namespace:path, $name:ident, [$($alias:literal),* $(,)?]) => {

crates/gpui/src/app.rs

@@ -35,10 +35,10 @@ use crate::{
     AssetSource, BackgroundExecutor, Bounds, ClipboardItem, CursorStyle, DispatchPhase, DisplayId,
     EventEmitter, FocusHandle, FocusMap, ForegroundExecutor, Global, KeyBinding, Keymap, Keystroke,
     LayoutId, Menu, MenuItem, OwnedMenu, PathPromptOptions, Pixels, Platform, PlatformDisplay,
-    PlatformKeyboardLayout, Point, PromptBuilder, PromptHandle, PromptLevel, Render,
-    RenderablePromptHandle, Reservation, ScreenCaptureSource, SharedString, SubscriberSet,
-    Subscription, SvgRenderer, Task, TextSystem, Window, WindowAppearance, WindowHandle, WindowId,
-    WindowInvalidator, current_platform, hash, init_app_menus,
+    Point, PromptBuilder, PromptHandle, PromptLevel, Render, RenderablePromptHandle, Reservation,
+    ScreenCaptureSource, SharedString, SubscriberSet, Subscription, SvgRenderer, Task, TextSystem,
+    Window, WindowAppearance, WindowHandle, WindowId, WindowInvalidator, current_platform, hash,
+    init_app_menus,
 };
 
 mod async_context;
@@ -248,7 +248,7 @@ pub struct App {
     pub(crate) window_handles: FxHashMap<WindowId, AnyWindowHandle>,
     pub(crate) focus_handles: Arc<FocusMap>,
     pub(crate) keymap: Rc<RefCell<Keymap>>,
-    pub(crate) keyboard_layout: Box<dyn PlatformKeyboardLayout>,
+    pub(crate) keyboard_layout: SharedString,
     pub(crate) global_action_listeners:
         FxHashMap<TypeId, Vec<Rc<dyn Fn(&dyn Any, DispatchPhase, &mut Self)>>>,
     pending_effects: VecDeque<Effect>,
@@ -289,7 +289,7 @@ impl App {
 
         let text_system = Arc::new(TextSystem::new(platform.text_system()));
         let entities = EntityMap::new();
-        let keyboard_layout = platform.keyboard_layout();
+        let keyboard_layout = SharedString::from(platform.keyboard_layout());
 
         let app = Rc::new_cyclic(|this| AppCell {
             app: RefCell::new(App {
@@ -345,7 +345,7 @@ impl App {
             move || {
                 if let Some(app) = app.upgrade() {
                     let cx = &mut app.borrow_mut();
-                    cx.keyboard_layout = cx.platform.keyboard_layout();
+                    cx.keyboard_layout = SharedString::from(cx.platform.keyboard_layout());
                     cx.keyboard_layout_observers
                         .clone()
                         .retain(&(), move |callback| (callback)(cx));
@@ -387,8 +387,8 @@ impl App {
     }
 
     /// Get the id of the current keyboard layout
-    pub fn keyboard_layout(&self) -> &dyn PlatformKeyboardLayout {
-        self.keyboard_layout.as_ref()
+    pub fn keyboard_layout(&self) -> &SharedString {
+        &self.keyboard_layout
     }
 
     /// Invokes a handler when the current keyboard layout changes
@@ -505,8 +505,8 @@ impl App {
         self.new_observer(
             entity_id,
             Box::new(move |cx| {
-                if let Some(entity) = handle.upgrade() {
-                    on_notify(entity, cx)
+                if let Some(handle) = Entity::<W>::upgrade_from(&handle) {
+                    on_notify(handle, cx)
                 } else {
                     false
                 }
@@ -550,15 +550,15 @@ impl App {
         Evt: 'static,
     {
         let entity_id = entity.entity_id();
-        let handle = entity.downgrade();
+        let entity = entity.downgrade();
         self.new_subscription(
             entity_id,
             (
                 TypeId::of::<Evt>(),
                 Box::new(move |event, cx| {
                     let event: &Evt = event.downcast_ref().expect("invalid event type");
-                    if let Some(entity) = handle.upgrade() {
-                        on_event(entity, event, cx)
+                    if let Some(handle) = Entity::<T>::upgrade_from(&entity) {
+                        on_event(handle, event, cx)
                     } else {
                         false
                     }

crates/gpui/src/app/context.rs

@@ -212,7 +212,7 @@ impl<'a, T: 'static> Context<'a, T> {
 
     /// Convenience method for accessing view state in an event callback.
     ///
-    /// Many GPUI callbacks take the form of `Fn(&E, &mut Window, &mut App)`,
+    /// Many GPUI callbacks take the form of `Fn(&E, &mut Window, &mut AppContext)`,
     /// but it's often useful to be able to access view state in these
     /// callbacks. This method provides a convenient way to do so.
     pub fn listener<E: ?Sized>(
@@ -608,8 +608,8 @@ impl<'a, T: 'static> Context<'a, T> {
     }
 
     /// Schedule a future to be run asynchronously.
-    /// The given callback is invoked with a [`WeakEntity<V>`] to avoid leaking the entity for a long-running process.
-    /// It's also given an [`AsyncWindowContext`], which can be used to access the state of the entity across await points.
+    /// The given callback is invoked with a [`WeakEntity<V>`] to avoid leaking the view for a long-running process.
+    /// It's also given an [`AsyncWindowContext`], which can be used to access the state of the view across await points.
     /// The returned future will be polled on the main thread.
     #[track_caller]
     pub fn spawn_in<AsyncFn, R>(&self, window: &Window, f: AsyncFn) -> Task<R>

crates/gpui/src/app/entity_map.rs

@@ -409,6 +409,17 @@ impl<T: 'static> Entity<T> {
         }
     }
 
+    /// Upgrade the given weak pointer to a retaining pointer, if it still exists
+    pub fn upgrade_from(weak: &WeakEntity<T>) -> Option<Self>
+    where
+        Self: Sized,
+    {
+        Some(Entity {
+            any_entity: weak.any_entity.upgrade()?,
+            entity_type: weak.entity_type,
+        })
+    }
+
     /// Convert this into a dynamically typed entity.
     pub fn into_any(self) -> AnyEntity {
         self.any_entity
@@ -429,22 +440,32 @@ impl<T: 'static> Entity<T> {
     }
 
     /// Updates the entity referenced by this handle with the given function.
-    pub fn update<R, C: AppContext>(
+    ///
+    /// The update function receives a context appropriate for its environment.
+    /// When updating in an `App`, it receives a `Context`.
+    /// When updating in a `Window`, it receives a `Window` and a `Context`.
+    pub fn update<C, R>(
         &self,
         cx: &mut C,
         update: impl FnOnce(&mut T, &mut Context<T>) -> R,
-    ) -> C::Result<R> {
+    ) -> C::Result<R>
+    where
+        C: AppContext,
+    {
         cx.update_entity(self, update)
     }
 
     /// Updates the entity referenced by this handle with the given function if
     /// the referenced entity still exists, within a visual context that has a window.
     /// Returns an error if the entity has been released.
-    pub fn update_in<R, C: VisualContext>(
+    pub fn update_in<C, R>(
         &self,
         cx: &mut C,
         update: impl FnOnce(&mut T, &mut Window, &mut Context<T>) -> R,
-    ) -> C::Result<R> {
+    ) -> C::Result<R>
+    where
+        C: VisualContext,
+    {
         cx.update_window_entity(self, update)
     }
 }
@@ -648,10 +669,8 @@ impl<T> Clone for WeakEntity<T> {
 impl<T: 'static> WeakEntity<T> {
     /// Upgrade this weak entity reference into a strong entity reference
     pub fn upgrade(&self) -> Option<Entity<T>> {
-        Some(Entity {
-            any_entity: self.any_entity.upgrade()?,
-            entity_type: self.entity_type,
-        })
+        // Delegate to the trait implementation to keep behavior in one place.
+        Entity::upgrade_from(self)
     }
 
     /// Updates the entity referenced by this handle with the given function if

crates/gpui/src/app/test_context.rs

@@ -113,7 +113,7 @@ impl AppContext for TestAppContext {
 
 impl TestAppContext {
     /// Creates a new `TestAppContext`. Usually you can rely on `#[gpui::test]` to do this for you.
-    pub fn build(dispatcher: TestDispatcher, fn_name: Option<&'static str>) -> Self {
+    pub fn new(dispatcher: TestDispatcher, fn_name: Option<&'static str>) -> Self {
         let arc_dispatcher = Arc::new(dispatcher.clone());
         let background_executor = BackgroundExecutor::new(arc_dispatcher.clone());
         let foreground_executor = ForegroundExecutor::new(arc_dispatcher);
@@ -146,7 +146,7 @@ impl TestAppContext {
 
     /// returns a new `TestAppContext` re-using the same executors to interleave tasks.
     pub fn new_app(&self) -> TestAppContext {
-        Self::build(self.dispatcher.clone(), self.fn_name)
+        Self::new(self.dispatcher.clone(), self.fn_name)
     }
 
     /// Called by the test helper to end the test.
@@ -178,11 +178,6 @@ impl TestAppContext {
         &self.foreground_executor
     }
 
-    fn new<T: 'static>(&mut self, build_entity: impl FnOnce(&mut Context<T>) -> T) -> Entity<T> {
-        let mut cx = self.app.borrow_mut();
-        cx.new(build_entity)
-    }
-
     /// Gives you an `&mut App` for the duration of the closure
     pub fn update<R>(&self, f: impl FnOnce(&mut App) -> R) -> R {
         let mut cx = self.app.borrow_mut();

crates/gpui/src/debug.rs

@@ -1 +0,0 @@
-pub(crate) mod inspector;

crates/gpui/src/debug/inspector.rs

@@ -1,231 +0,0 @@
-use crate::{
-    AnyElement, App, Bounds, Context, ElementId, GlobalElementId, InteractiveElement, IntoElement,
-    ParentElement, Pixels, Render, SharedString, Style, StyleRefinement, Styled, Window, div, px,
-    rgb, util::FluentBuilder,
-};
-use std::collections::HashMap;
-
-/// Metadata about an element for inspection purposes
-#[derive(Default, Clone)]
-pub struct ElementMetadata {
-    pub bounds: Option<Bounds<Pixels>>,
-    pub style: Option<Style>,
-    pub children: Vec<ElementId>,
-    pub parent: Option<GlobalElementId>,
-}
-
-pub(crate) struct Inspector {
-    selected_element: Option<GlobalElementId>,
-    element_hover: Option<GlobalElementId>,
-    expanded_elements: HashMap<GlobalElementId, bool>,
-}
-
-impl Default for Inspector {
-    fn default() -> Self {
-        Self {
-            selected_element: None,
-            element_hover: None,
-            expanded_elements: HashMap::new(),
-        }
-    }
-}
-
-impl Render for Inspector {
-    fn render(
-        &mut self,
-        window: &mut crate::Window,
-        cx: &mut crate::Context<Self>,
-    ) -> impl IntoElement {
-        let mut has_info = false;
-        let selected_element_info = if let Some(id) = &self.selected_element {
-            has_info = true;
-            self.get_element(window, id)
-        } else {
-            has_info = false;
-            None
-        };
-
-        div()
-            .id("GPUI_TOOLS_INSPECTOR")
-            .flex()
-            .flex_col()
-            .size_full()
-            .bg(rgb(0xf0f0f0))
-            .p_4()
-            .gap_4()
-            .child(
-                // Header
-                div()
-                    .flex()
-                    .w_full()
-                    .justify_between()
-                    .pb_2()
-                    .border_b_1()
-                    .border_color(rgb(0xdddddd))
-                    .child("GPUI Element Inspector"),
-            )
-            .child(
-                // Element info section
-                div()
-                    .flex()
-                    .flex_col()
-                    .gap_2()
-                    .when_some(selected_element_info.clone(), |this, info| {
-                        this.child(
-                            div()
-                                .flex()
-                                .flex_col()
-                                .p_2()
-                                .bg(rgb(0xffffff))
-                                .border_1()
-                                .border_color(rgb(0xdddddd))
-                                .rounded_md()
-                                .child(div().child(format!(
-                                    "Element: {:?}",
-                                    self.selected_element.as_ref().unwrap()
-                                )))
-                                .when_some(info.bounds, |this, bounds| {
-                                    this.child(format!("Bounds: {:?}", bounds))
-                                }),
-                        )
-                    })
-                    .when(has_info, |this| {
-                        this.child(
-                            div()
-                                .p_2()
-                                .child("No element selected. Use the mouse to select an element."),
-                        )
-                    }),
-            )
-            .child(
-                // Element style section
-                div().flex().flex_col().gap_2().when_some(
-                    selected_element_info,
-                    |this, element| {
-                        this.when_some(element.style.as_ref(), |this, style| {
-                            this.child(
-                                div()
-                                    .flex()
-                                    .flex_col()
-                                    .p_2()
-                                    .bg(rgb(0xffffff))
-                                    .border_1()
-                                    .border_color(rgb(0xdddddd))
-                                    .rounded_md()
-                                    .child(div().child("Style Properties:"))
-                                    .child(self.render_style_properties(style)),
-                            )
-                        })
-                    },
-                ),
-            )
-    }
-}
-
-impl Inspector {
-    fn property_div(
-        &self,
-        name: impl Into<SharedString>,
-        value: impl Into<Option<SharedString>>,
-    ) -> Option<impl IntoElement> {
-        if let Some(value) = value.into() {
-            let property_string: SharedString = format!("{:?}", value.into()).into();
-
-            Some(
-                div()
-                    .flex()
-                    .gap_2()
-                    .child(div().text_xs().text_color(rgb(0x666666)).child(name.into()))
-                    .child(div().text_xs().child(property_string)),
-            )
-        } else {
-            None
-        }
-    }
-
-    /// Render the style properties of an element
-    fn render_style_properties(&self, style: &Style) -> impl IntoElement {
-        let width: SharedString = format!("{:?}", style.size.width).into();
-        let height: SharedString = format!("{:?}", style.size.height).into();
-
-        div()
-            .flex()
-            .flex_col()
-            .gap_1()
-            .px_2()
-            .children(self.property_div("width", width))
-            .children(self.property_div("height", height))
-        // .children(self.property_div("background", style.background))
-        // .children(self.property_div("color", style.text_color))
-        // .children(self.property_div("font_size", style.font_size))
-        // .children(self.property_div("font_weight", style.font_weight))
-        // .children(self.property_div("padding", style.padding))
-        // .children(self.property_div("margin", style.margin))
-        // .children(self.property_div("border", style.border))
-        // .children(self.property_div("border_color", style.border_color))
-        // .children(self.property_div("border_radius", style.border_radius))
-    }
-
-    /// Get element metadata by GlobalElementId
-    pub fn get_element(
-        &self,
-        window: &mut Window,
-        id: &GlobalElementId,
-    ) -> Option<ElementMetadata> {
-        let mut result = None;
-        window.with_element_state(id, |state: Option<&ElementMetadata>, _window| {
-            result = state.cloned();
-            ((), &result.unwrap_or_default())
-        });
-        result
-    }
-
-    /// Select an element for inspection
-    pub fn select_element(&mut self, id: GlobalElementId) {
-        self.selected_element = Some(id);
-    }
-
-    /// Set hover state for an element
-    pub fn hover_element(&mut self, id: Option<GlobalElementId>) {
-        self.element_hover = id;
-    }
-
-    /// Toggle expanded state of an element in the tree view
-    pub fn toggle_expanded(&mut self, id: &GlobalElementId) {
-        let is_expanded = self.expanded_elements.get(id).copied().unwrap_or(false);
-        self.expanded_elements.insert(id.clone(), !is_expanded);
-    }
-
-    /// Check if an element is expanded in the tree view
-    pub fn is_expanded(&self, id: &GlobalElementId) -> bool {
-        self.expanded_elements.get(id).copied().unwrap_or(false)
-    }
-
-    /// Register an element for inspection
-    pub fn register_element(
-        window: &mut Window,
-        id: &GlobalElementId,
-        bounds: Bounds<Pixels>,
-        style: Style,
-        parent: Option<GlobalElementId>,
-    ) {
-        window.with_element_state(id, |existing: Option<ElementMetadata>, _window| {
-            let mut metadata = existing.unwrap_or_default();
-            metadata.bounds = Some(bounds);
-            metadata.style = Some(style);
-            metadata.parent = parent;
-            ((), metadata)
-        });
-    }
-
-    /// Add a child to a parent element's metadata
-    pub fn register_child(window: &mut Window, parent_id: &GlobalElementId, child_id: ElementId) {
-        window.with_element_state(parent_id, |existing: Option<ElementMetadata>, _window| {
-            let mut metadata = existing.unwrap_or_default();
-            if !metadata.children.contains(&child_id) {
-                metadata.children.push(child_id);
-            }
-            ((), metadata)
-        });
-    }
-}

crates/gpui/src/element.rs

@@ -35,28 +35,10 @@ use crate::{
     App, ArenaBox, AvailableSpace, Bounds, Context, DispatchNodeId, ELEMENT_ARENA, ElementId,
     FocusHandle, LayoutId, Pixels, Point, Size, Style, Window, util::FluentBuilder,
 };
-
 use derive_more::{Deref, DerefMut};
 pub(crate) use smallvec::SmallVec;
 use std::{any::Any, fmt::Debug, mem};
 
-/// Register an element for inspection if DevTools are enabled
-pub fn register_for_inspection(
-    window: &mut Window,
-    id: &GlobalElementId,
-    bounds: Bounds<Pixels>,
-    style: Option<Style>,
-    parent: Option<GlobalElementId>,
-) {
-    if !window.show_devtools {
-        return;
-    }
-
-    if let Some(style) = style {
-        crate::debug::inspector::Inspector::register_element(window, id, bounds, style, parent);
-    }
-}
-
 /// Implemented by types that participate in laying out and painting the contents of a window.
 /// Elements form a tree and are laid out according to web-based layout rules, as implemented by Taffy.
 /// You can create custom elements by implementing this trait, see the module-level documentation
@@ -247,8 +229,6 @@ impl<C: RenderOnce> IntoElement for Component<C> {
 
 /// A globally unique identifier for an element, used to track state across frames.
 #[derive(Deref, DerefMut, Default, Debug, Eq, PartialEq, Hash)]
-// todo!("this shouldn't be clone")
-#[derive(Clone)]
 pub struct GlobalElementId(pub(crate) SmallVec<[ElementId; 32]>);
 
 trait ElementObject {

crates/gpui/src/gpui.rs

@@ -73,7 +73,6 @@ mod asset_cache;
 mod assets;
 mod bounds_tree;
 mod color;
-mod debug;
 mod element;
 mod elements;
 mod executor;

crates/gpui/src/platform.rs

@@ -214,7 +214,7 @@ pub(crate) trait Platform: 'static {
     fn on_app_menu_action(&self, callback: Box<dyn FnMut(&dyn Action)>);
     fn on_will_open_app_menu(&self, callback: Box<dyn FnMut()>);
     fn on_validate_app_menu_command(&self, callback: Box<dyn FnMut(&dyn Action) -> bool>);
-    fn keyboard_layout(&self) -> Box<dyn PlatformKeyboardLayout>;
+    fn keyboard_layout(&self) -> String;
 
     fn compositor_name(&self) -> &'static str {
         ""
@@ -1027,9 +1027,6 @@ pub struct WindowOptions {
     /// Whether the window should be movable by the user
     pub is_movable: bool,
 
-    /// Whether to show a devtools panel on the right side
-    pub show_devtools: bool,
-
     /// The display to create the window on, if this is None,
     /// the window will be created on the main display
     pub display_id: Option<DisplayId>,
@@ -1127,7 +1124,6 @@ impl Default for WindowOptions {
             show: true,
             kind: WindowKind::Normal,
             is_movable: true,
-            show_devtools: false,
             display_id: None,
             window_background: WindowBackgroundAppearance::default(),
             app_id: None,
@@ -1638,11 +1634,3 @@ impl From<String> for ClipboardString {
         }
     }
 }
-
-/// A trait for platform-specific keyboard layouts
-pub trait PlatformKeyboardLayout {
-    /// Get the keyboard layout ID, which should be unique to the layout
-    fn id(&self) -> &str;
-    /// Get the keyboard layout display name
-    fn name(&self) -> &str;
-}

crates/gpui/src/platform/keystroke.rs

@@ -318,18 +318,10 @@ fn is_printable_key(key: &str) -> bool {
 impl std::fmt::Display for Keystroke {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if self.modifiers.control {
-            if cfg!(target_os = "macos") {
-                f.write_char('^')?;
-            } else {
-                write!(f, "ctrl-")?;
-            }
+            f.write_char('^')?;
         }
         if self.modifiers.alt {
-            if cfg!(target_os = "macos") {
-                f.write_char('⌥')?;
-            } else {
-                write!(f, "alt-")?;
-            }
+            f.write_char('⌥')?;
         }
         if self.modifiers.platform {
             #[cfg(target_os = "macos")]
@@ -342,24 +334,20 @@ impl std::fmt::Display for Keystroke {
             f.write_char('⊞')?;
         }
         if self.modifiers.shift {
-            if cfg!(target_os = "macos") {
-                f.write_char('⇧')?;
-            } else {
-                write!(f, "shift-")?;
-            }
+            f.write_char('⇧')?;
         }
         let key = match self.key.as_str() {
-            "backspace" if cfg!(target_os = "macos") => '⌫',
-            "up" if cfg!(target_os = "macos") => '↑',
-            "down" if cfg!(target_os = "macos") => '↓',
-            "left" if cfg!(target_os = "macos") => '←',
-            "right" if cfg!(target_os = "macos") => '→',
-            "tab" if cfg!(target_os = "macos") => '⇥',
-            "escape" if cfg!(target_os = "macos") => '⎋',
-            "shift" if cfg!(target_os = "macos") => '⇧',
-            "control" if cfg!(target_os = "macos") => '⌃',
-            "alt" if cfg!(target_os = "macos") => '⌥',
-            "platform" if cfg!(target_os = "macos") => '⌘',
+            "backspace" => '⌫',
+            "up" => '↑',
+            "down" => '↓',
+            "left" => '←',
+            "right" => '→',
+            "tab" => '⇥',
+            "escape" => '⎋',
+            "shift" => '⇧',
+            "control" => '⌃',
+            "alt" => '⌥',
+            "platform" => '⌘',
             key => {
                 if key.len() == 1 {
                     key.chars().next().unwrap().to_ascii_uppercase()

crates/gpui/src/platform/linux/headless/client.rs

@@ -9,8 +9,7 @@ use util::ResultExt;
 use crate::platform::linux::LinuxClient;
 use crate::platform::{LinuxCommon, PlatformWindow};
 use crate::{
-    AnyWindowHandle, CursorStyle, DisplayId, LinuxKeyboardLayout, PlatformDisplay,
-    PlatformKeyboardLayout, ScreenCaptureSource, WindowParams,
+    AnyWindowHandle, CursorStyle, DisplayId, PlatformDisplay, ScreenCaptureSource, WindowParams,
 };
 
 pub struct HeadlessClientState {
@@ -51,8 +50,8 @@ impl LinuxClient for HeadlessClient {
         f(&mut self.0.borrow_mut().common)
     }
 
-    fn keyboard_layout(&self) -> Box<dyn PlatformKeyboardLayout> {
-        Box::new(LinuxKeyboardLayout::new("unknown".to_string()))
+    fn keyboard_layout(&self) -> String {
+        "unknown".to_string()
     }
 
     fn displays(&self) -> Vec<Rc<dyn PlatformDisplay>> {

crates/gpui/src/platform/linux/platform.rs

@@ -25,8 +25,8 @@ use xkbcommon::xkb::{self, Keycode, Keysym, State};
 use crate::{
     Action, AnyWindowHandle, BackgroundExecutor, ClipboardItem, CursorStyle, DisplayId,
     ForegroundExecutor, Keymap, LinuxDispatcher, Menu, MenuItem, OwnedMenu, PathPromptOptions,
-    Pixels, Platform, PlatformDisplay, PlatformKeyboardLayout, PlatformTextSystem, PlatformWindow,
-    Point, Result, ScreenCaptureSource, Task, WindowAppearance, WindowParams, px,
+    Pixels, Platform, PlatformDisplay, PlatformTextSystem, PlatformWindow, Point, Result,
+    ScreenCaptureSource, Task, WindowAppearance, WindowParams, px,
 };
 
 #[cfg(any(feature = "wayland", feature = "x11"))]
@@ -46,7 +46,7 @@ const FILE_PICKER_PORTAL_MISSING: &str =
 pub trait LinuxClient {
     fn compositor_name(&self) -> &'static str;
     fn with_common<R>(&self, f: impl FnOnce(&mut LinuxCommon) -> R) -> R;
-    fn keyboard_layout(&self) -> Box<dyn PlatformKeyboardLayout>;
+    fn keyboard_layout(&self) -> String;
     fn displays(&self) -> Vec<Rc<dyn PlatformDisplay>>;
     #[allow(unused)]
     fn display(&self, id: DisplayId) -> Option<Rc<dyn PlatformDisplay>>;
@@ -138,7 +138,7 @@ impl<P: LinuxClient + 'static> Platform for P {
         self.with_common(|common| common.text_system.clone())
     }
 
-    fn keyboard_layout(&self) -> Box<dyn PlatformKeyboardLayout> {
+    fn keyboard_layout(&self) -> String {
         self.keyboard_layout()
     }
 
@@ -858,26 +858,6 @@ impl crate::Modifiers {
     }
 }
 
-pub(crate) struct LinuxKeyboardLayout {
-    id: String,
-}
-
-impl PlatformKeyboardLayout for LinuxKeyboardLayout {
-    fn id(&self) -> &str {
-        &self.id
-    }
-
-    fn name(&self) -> &str {
-        &self.id
-    }
-}
-
-impl LinuxKeyboardLayout {
-    pub(crate) fn new(id: String) -> Self {
-        Self { id }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

crates/gpui/src/platform/linux/wayland/client.rs

@@ -66,10 +66,8 @@ use wayland_protocols_plasma::blur::client::{org_kde_kwin_blur, org_kde_kwin_blu
 use xkbcommon::xkb::ffi::XKB_KEYMAP_FORMAT_TEXT_V1;
 use xkbcommon::xkb::{self, KEYMAP_COMPILE_NO_FLAGS, Keycode};
 
-use super::{
-    display::WaylandDisplay,
-    window::{ImeInput, WaylandWindowStatePtr},
-};
+use super::display::WaylandDisplay;
+use super::window::{ImeInput, WaylandWindowStatePtr};
 
 use crate::platform::linux::{
     LinuxClient, get_xkb_compose_state, is_within_click_distance, open_uri_internal, read_fd,
@@ -85,11 +83,11 @@ use crate::platform::linux::{
 use crate::platform::{PlatformWindow, blade::BladeContext};
 use crate::{
     AnyWindowHandle, Bounds, CursorStyle, DOUBLE_CLICK_INTERVAL, DevicePixels, DisplayId,
-    FileDropEvent, ForegroundExecutor, KeyDownEvent, KeyUpEvent, Keystroke, LinuxCommon,
-    LinuxKeyboardLayout, Modifiers, ModifiersChangedEvent, MouseButton, MouseDownEvent,
-    MouseExitEvent, MouseMoveEvent, MouseUpEvent, NavigationDirection, Pixels, PlatformDisplay,
-    PlatformInput, PlatformKeyboardLayout, Point, SCROLL_LINES, ScaledPixels, ScreenCaptureSource,
-    ScrollDelta, ScrollWheelEvent, Size, TouchPhase, WindowParams, point, px, size,
+    FileDropEvent, ForegroundExecutor, KeyDownEvent, KeyUpEvent, Keystroke, LinuxCommon, Modifiers,
+    ModifiersChangedEvent, MouseButton, MouseDownEvent, MouseExitEvent, MouseMoveEvent,
+    MouseUpEvent, NavigationDirection, Pixels, PlatformDisplay, PlatformInput, Point, SCROLL_LINES,
+    ScaledPixels, ScreenCaptureSource, ScrollDelta, ScrollWheelEvent, Size, TouchPhase,
+    WindowParams, point, px, size,
 };
 
 /// Used to convert evdev scancode to xkb scancode
@@ -589,9 +587,9 @@ impl WaylandClient {
 }
 
 impl LinuxClient for WaylandClient {
-    fn keyboard_layout(&self) -> Box<dyn PlatformKeyboardLayout> {
+    fn keyboard_layout(&self) -> String {
         let state = self.0.borrow();
-        let id = if let Some(keymap_state) = &state.keymap_state {
+        if let Some(keymap_state) = &state.keymap_state {
             let layout_idx = keymap_state.serialize_layout(xkbcommon::xkb::STATE_LAYOUT_EFFECTIVE);
             keymap_state
                 .get_keymap()
@@ -599,8 +597,7 @@ impl LinuxClient for WaylandClient {
                 .to_string()
         } else {
             "unknown".to_string()
-        };
-        Box::new(LinuxKeyboardLayout::new(id))
+        }
     }
 
     fn displays(&self) -> Vec<Rc<dyn PlatformDisplay>> {
@@ -1501,13 +1498,7 @@ impl Dispatch<wl_pointer::WlPointer, ()> for WaylandClientStatePtr {
                         state.enter_token = None;
                     }
                     if let Some(style) = state.cursor_style {
-                        if let CursorStyle::None = style {
-                            let wl_pointer = state
-                                .wl_pointer
-                                .clone()
-                                .expect("window is focused by pointer");
-                            wl_pointer.set_cursor(serial, None, 0, 0);
-                        } else if let Some(cursor_shape_device) = &state.cursor_shape_device {
+                        if let Some(cursor_shape_device) = &state.cursor_shape_device {
                             cursor_shape_device.set_shape(serial, style.to_shape());
                         } else {
                             let scale = window.primary_output_scale();

crates/gpui/src/platform/linux/x11/client.rs

@@ -59,10 +59,9 @@ use crate::platform::{
 };
 use crate::{
     AnyWindowHandle, Bounds, ClipboardItem, CursorStyle, DisplayId, FileDropEvent, Keystroke,
-    LinuxKeyboardLayout, Modifiers, ModifiersChangedEvent, MouseButton, Pixels, Platform,
-    PlatformDisplay, PlatformInput, PlatformKeyboardLayout, Point, RequestFrameOptions,
-    ScaledPixels, ScreenCaptureSource, ScrollDelta, Size, TouchPhase, WindowParams, X11Window,
-    modifiers_from_xinput_info, point, px,
+    Modifiers, ModifiersChangedEvent, MouseButton, Pixels, Platform, PlatformDisplay,
+    PlatformInput, Point, RequestFrameOptions, ScaledPixels, ScreenCaptureSource, ScrollDelta,
+    Size, TouchPhase, WindowParams, X11Window, modifiers_from_xinput_info, point, px,
 };
 
 /// Value for DeviceId parameters which selects all devices.
@@ -1283,16 +1282,14 @@ impl LinuxClient for X11Client {
         f(&mut self.0.borrow_mut().common)
     }
 
-    fn keyboard_layout(&self) -> Box<dyn PlatformKeyboardLayout> {
+    fn keyboard_layout(&self) -> String {
         let state = self.0.borrow();
         let layout_idx = state.xkb.serialize_layout(STATE_LAYOUT_EFFECTIVE);
-        Box::new(LinuxKeyboardLayout::new(
-            state
-                .xkb
-                .get_keymap()
-                .layout_get_name(layout_idx)
-                .to_string(),
-        ))
+        state
+            .xkb
+            .get_keymap()
+            .layout_get_name(layout_idx)
+            .to_string()
     }
 
     fn displays(&self) -> Vec<Rc<dyn PlatformDisplay>> {

crates/gpui/src/platform/mac/platform.rs

@@ -7,9 +7,9 @@ use super::{
 use crate::{
     Action, AnyWindowHandle, BackgroundExecutor, ClipboardEntry, ClipboardItem, ClipboardString,
     CursorStyle, ForegroundExecutor, Image, ImageFormat, Keymap, MacDispatcher, MacDisplay,
-    MacWindow, Menu, MenuItem, PathPromptOptions, Platform, PlatformDisplay,
-    PlatformKeyboardLayout, PlatformTextSystem, PlatformWindow, Result, ScreenCaptureSource,
-    SemanticVersion, Task, WindowAppearance, WindowParams, hash,
+    MacWindow, Menu, MenuItem, PathPromptOptions, Platform, PlatformDisplay, PlatformTextSystem,
+    PlatformWindow, Result, ScreenCaptureSource, SemanticVersion, Task, WindowAppearance,
+    WindowParams, hash,
 };
 use anyhow::{Context as _, anyhow};
 use block::ConcreteBlock;
@@ -353,7 +353,8 @@ impl MacPlatform {
                                     ns_string(key_to_native(&keystroke.key).as_ref()),
                                 )
                                 .autorelease();
-                            if Self::os_version() >= SemanticVersion::new(12, 0, 0) {
+                            if MacPlatform::os_version().unwrap() >= SemanticVersion::new(12, 0, 0)
+                            {
                                 let _: () = msg_send![item, setAllowsAutomaticKeyEquivalentLocalization: NO];
                             }
                             item.setKeyEquivalentModifierMask_(mask);
@@ -401,16 +402,16 @@ impl MacPlatform {
         }
     }
 
-    fn os_version() -> SemanticVersion {
-        let version = unsafe {
+    fn os_version() -> Result<SemanticVersion> {
+        unsafe {
             let process_info = NSProcessInfo::processInfo(nil);
-            process_info.operatingSystemVersion()
-        };
-        SemanticVersion::new(
-            version.majorVersion as usize,
-            version.minorVersion as usize,
-            version.patchVersion as usize,
-        )
+            let version = process_info.operatingSystemVersion();
+            Ok(SemanticVersion::new(
+                version.majorVersion as usize,
+                version.minorVersion as usize,
+                version.patchVersion as usize,
+            ))
+        }
     }
 }
 
@@ -608,7 +609,7 @@ impl Platform for MacPlatform {
         // API only available post Monterey
         // https://developer.apple.com/documentation/appkit/nsworkspace/3753004-setdefaultapplicationaturl
         let (done_tx, done_rx) = oneshot::channel();
-        if Self::os_version() < SemanticVersion::new(12, 0, 0) {
+        if Self::os_version().ok() < Some(SemanticVersion::new(12, 0, 0)) {
             return Task::ready(Err(anyhow!(
                 "macOS 12.0 or later is required to register URL schemes"
             )));
@@ -735,7 +736,9 @@ impl Platform for MacPlatform {
                                     // you can manually create a file called `a.sql.s`. That said it seems better
                                     // to break that use-case than breaking `a.sql`.
                                     if chunks.len() == 3 && chunks[1].starts_with(chunks[2]) {
-                                        if Self::os_version() >= SemanticVersion::new(15, 0, 0) {
+                                        if Self::os_version()
+                                            .is_ok_and(|v| v >= SemanticVersion::new(15, 0, 0))
+                                        {
                                             let new_filename = OsStr::from_bytes(
                                                 &filename.as_bytes()
                                                     [..chunks[0].len() + 1 + chunks[1].len()],
@@ -825,8 +828,20 @@ impl Platform for MacPlatform {
         self.0.lock().validate_menu_command = Some(callback);
     }
 
-    fn keyboard_layout(&self) -> Box<dyn PlatformKeyboardLayout> {
-        Box::new(MacKeyboardLayout::new())
+    fn keyboard_layout(&self) -> String {
+        unsafe {
+            let current_keyboard = TISCopyCurrentKeyboardLayoutInputSource();
+
+            let input_source_id: *mut Object = TISGetInputSourceProperty(
+                current_keyboard,
+                kTISPropertyInputSourceID as *const c_void,
+            );
+            let input_source_id: *const std::os::raw::c_char =
+                msg_send![input_source_id, UTF8String];
+            let input_source_id = CStr::from_ptr(input_source_id).to_str().unwrap();
+
+            input_source_id.to_string()
+        }
     }
 
     fn app_path(&self) -> Result<PathBuf> {
@@ -1489,7 +1504,6 @@ unsafe extern "C" {
     pub(super) fn LMGetKbdType() -> u16;
     pub(super) static kTISPropertyUnicodeKeyLayoutData: CFStringRef;
     pub(super) static kTISPropertyInputSourceID: CFStringRef;
-    pub(super) static kTISPropertyLocalizedName: CFStringRef;
 }
 
 mod security {
@@ -1579,45 +1593,6 @@ impl UTType {
     }
 }
 
-struct MacKeyboardLayout {
-    id: String,
-    name: String,
-}
-
-impl PlatformKeyboardLayout for MacKeyboardLayout {
-    fn id(&self) -> &str {
-        &self.id
-    }
-
-    fn name(&self) -> &str {
-        &self.name
-    }
-}
-
-impl MacKeyboardLayout {
-    fn new() -> Self {
-        unsafe {
-            let current_keyboard = TISCopyCurrentKeyboardLayoutInputSource();
-
-            let id: *mut Object = TISGetInputSourceProperty(
-                current_keyboard,
-                kTISPropertyInputSourceID as *const c_void,
-            );
-            let id: *const std::os::raw::c_char = msg_send![id, UTF8String];
-            let id = CStr::from_ptr(id).to_str().unwrap().to_string();
-
-            let name: *mut Object = TISGetInputSourceProperty(
-                current_keyboard,
-                kTISPropertyLocalizedName as *const c_void,
-            );
-            let name: *const std::os::raw::c_char = msg_send![name, UTF8String];
-            let name = CStr::from_ptr(name).to_str().unwrap().to_string();
-
-            Self { id, name }
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use crate::ClipboardItem;