open_ai: Configurable model capabilities

Remove /docs slash command (#36325 )
This PR removes the `/docs` slash command. We never fully shipped this—with it requiring explicit opt-in via a setting—and it doesn't seem like the feature is needed in an agentic world. Release Notes: - Removed the `/docs` slash command.
2025-08-17 11:27:52 +03:00 · 2025-08-16 19:00:31 +00:00 · 2025-08-16 17:02:51 +00:00 · 2025-08-16 15:04:09 +00:00 · 2025-08-16 14:35:06 +00:00 · 2025-08-16 14:11:36 +00:00
362 changed files with 13699 additions and 13168 deletions
--- a/.config/hakari.toml
+++ b/.config/hakari.toml
@@ -25,6 +25,8 @@ third-party = [
    { name = "reqwest", version = "0.11.27" },
    # build of remote_server should not include scap / its x11 dependency
    { name = "scap", git = "https://github.com/zed-industries/scap", rev = "808aa5c45b41e8f44729d02e38fd00a2fe2722e7" },
+    # build of remote_server should not need to include on libalsa through rodio
+    { name = "rodio" },
 ]

 [final-excludes]
@@ -32,7 +34,6 @@ workspace-members = [
    "zed_extension_api",

    # exclude all extensions
-    "zed_emmet",
    "zed_glsl",
    "zed_html",
    "zed_proto",
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -718,7 +718,7 @@ jobs:
    timeout-minutes: 60
    runs-on: github-8vcpu-ubuntu-2404
    if: |
-      ( startsWith(github.ref, 'refs/tags/v')
+      false && ( startsWith(github.ref, 'refs/tags/v')
      || contains(github.event.pull_request.labels.*.name, 'run-bundling') )
    needs: [linux_tests]
    name: Build Zed on FreeBSD
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -7,20 +7,23 @@ name = "acp_thread"
 version = "0.1.0"
 dependencies = [
 "action_log",
+ "agent",
 "agent-client-protocol",
 "anyhow",
 "buffer_diff",
+ "collections",
 "editor",
 "env_logger 0.11.8",
+ "file_icons",
 "futures 0.3.31",
 "gpui",
 "indoc",
 "itertools 0.14.0",
 "language",
- "language_model",
 "markdown",
 "parking_lot",
 "project",
+ "prompt_store",
 "rand 0.8.5",
 "serde",
 "serde_json",
@@ -31,6 +34,8 @@ dependencies = [
 "ui",
 "url",
 "util",
+ "uuid",
+ "watch",
 "workspace-hack",
 ]

@@ -167,9 +172,9 @@ dependencies = [

 [[package]]
 name = "agent-client-protocol"
-version = "0.0.23"
+version = "0.0.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fad72b7b8ee4331b3a4c8d43c107e982a4725564b4ee658ae5c4e79d2b486e8"
+checksum = "2ab66add8be8d6a963f5bf4070045c1bbf36472837654c73e2298dd16bda5bf7"
 dependencies = [
 "anyhow",
 "futures 0.3.31",
@@ -231,6 +236,7 @@ dependencies = [
 "task",
 "tempfile",
 "terminal",
+ "text",
 "theme",
 "tree-sitter-rust",
 "ui",
@@ -341,7 +347,6 @@ dependencies = [
 "gpui",
 "html_to_markdown",
 "http_client",
- "indexed_docs",
 "indoc",
 "inventory",
 "itertools 0.14.0",
@@ -389,6 +394,7 @@ dependencies = [
 "ui",
 "ui_input",
 "unindent",
+ "url",
 "urlencoding",
 "util",
 "uuid",
@@ -865,7 +871,6 @@ dependencies = [
 "gpui",
 "html_to_markdown",
 "http_client",
- "indexed_docs",
 "language",
 "pretty_assertions",
 "project",
@@ -1255,26 +1260,6 @@ dependencies = [
 "syn 2.0.101",
 ]

-[[package]]
-name = "async-stripe"
-version = "0.40.0"
-source = "git+https://github.com/zed-industries/async-stripe?rev=3672dd4efb7181aa597bf580bf5a2f5d23db6735#3672dd4efb7181aa597bf580bf5a2f5d23db6735"
-dependencies = [
- "chrono",
- "futures-util",
- "http-types",
- "hyper 0.14.32",
- "hyper-rustls 0.24.2",
- "serde",
- "serde_json",
- "serde_path_to_error",
- "serde_qs 0.10.1",
- "smart-default 0.6.0",
- "smol_str 0.1.24",
- "thiserror 1.0.69",
- "tokio",
-]
-
 [[package]]
 name = "async-tar"
 version = "0.5.0"
@@ -1297,9 +1282,9 @@ checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de"

 [[package]]
 name = "async-trait"
-version = "0.1.88"
+version = "0.1.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e539d3fca749fcee5236ab05e93a52867dd549cc157c8cb7f99595f3cedffdb5"
+checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -2076,12 +2061,6 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "349a06037c7bf932dd7e7d1f653678b2038b9ad46a74102f1fc7bd7872678cce"

-[[package]]
-name = "base64"
-version = "0.13.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
-
 [[package]]
 name = "base64"
 version = "0.21.7"
@@ -3274,7 +3253,6 @@ dependencies = [
 "anyhow",
 "assistant_context",
 "assistant_slash_command",
- "async-stripe",
 "async-trait",
 "async-tungstenite",
 "audio",
@@ -3290,7 +3268,6 @@ dependencies = [
 "chrono",
 "client",
 "clock",
- "cloud_llm_client",
 "collab_ui",
 "collections",
 "command_palette_hooks",
@@ -3301,7 +3278,6 @@ dependencies = [
 "dap_adapters",
 "dashmap 6.1.0",
 "debugger_ui",
- "derive_more 0.99.19",
 "editor",
 "envy",
 "extension",
@@ -3317,7 +3293,6 @@ dependencies = [
 "http_client",
 "hyper 0.14.32",
 "indoc",
- "jsonwebtoken",
 "language",
 "language_model",
 "livekit_api",
@@ -3363,7 +3338,6 @@ dependencies = [
 "telemetry_events",
 "text",
 "theme",
- "thiserror 2.0.12",
 "time",
 "tokio",
 "toml 0.8.20",
@@ -3865,7 +3839,7 @@ dependencies = [
 "rustc-hash 1.1.0",
 "rustybuzz 0.14.1",
 "self_cell",
- "smol_str 0.2.2",
+ "smol_str",
 "swash",
 "sys-locale",
 "ttf-parser 0.21.1",
@@ -4062,6 +4036,8 @@ dependencies = [
 "minidumper",
 "paths",
 "release_channel",
+ "serde",
+ "serde_json",
 "smol",
 "workspace-hack",
 ]
@@ -6369,17 +6345,6 @@ dependencies = [
 "windows-targets 0.48.5",
 ]

-[[package]]
-name = "getrandom"
-version = "0.1.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"
-dependencies = [
- "cfg-if",
- "libc",
- "wasi 0.9.0+wasi-snapshot-preview1",
-]
-
 [[package]]
 name = "getrandom"
 version = "0.2.15"
@@ -6444,6 +6409,7 @@ dependencies = [
 "log",
 "parking_lot",
 "pretty_assertions",
+ "rand 0.8.5",
 "regex",
 "rope",
 "schemars",
@@ -7875,6 +7841,12 @@ dependencies = [
 "windows-sys 0.59.0",
 ]

+[[package]]
+name = "hound"
+version = "3.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62adaabb884c94955b19907d60019f4e145d091c75345379e70d1ee696f7854f"
+
 [[package]]
 name = "html5ever"
 version = "0.27.0"
@@ -7976,27 +7948,6 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "add0ab9360ddbd88cfeb3bd9574a1d85cfdfa14db10b3e21d3700dbc4328758f"

-[[package]]
-name = "http-types"
-version = "2.12.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e9b187a72d63adbfba487f48095306ac823049cb504ee195541e91c7775f5ad"
-dependencies = [
- "anyhow",
- "async-channel 1.9.0",
- "base64 0.13.1",
- "futures-lite 1.13.0",
- "http 0.2.12",
- "infer",
- "pin-project-lite",
- "rand 0.7.3",
- "serde",
- "serde_json",
- "serde_qs 0.8.5",
- "serde_urlencoded",
- "url",
-]
-
 [[package]]
 name = "http_client"
 version = "0.1.0"
@@ -8430,34 +8381,6 @@ version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d0263a3d970d5c054ed9312c0057b4f3bde9c0b33836d3637361d4a9e6e7a408"

-[[package]]
-name = "indexed_docs"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "async-trait",
- "cargo_metadata",
- "collections",
- "derive_more 0.99.19",
- "extension",
- "fs",
- "futures 0.3.31",
- "fuzzy",
- "gpui",
- "heed",
- "html_to_markdown",
- "http_client",
- "indexmap",
- "indoc",
- "parking_lot",
- "paths",
- "pretty_assertions",
- "serde",
- "strum 0.27.1",
- "util",
- "workspace-hack",
-]
-
 [[package]]
 name = "indexmap"
 version = "2.9.0"
@@ -8475,12 +8398,6 @@ version = "2.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f4c7245a08504955605670dbf141fceab975f15ca21570696aebe9d2e71576bd"

-[[package]]
-name = "infer"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64e9829a50b42bb782c1df523f78d332fe371b10c661e78b7a3c34b0198e9fac"
-
 [[package]]
 name = "inherent"
 version = "1.0.12"
@@ -9703,6 +9620,7 @@ dependencies = [
 "objc",
 "parking_lot",
 "postage",
+ "rodio",
 "scap",
 "serde",
 "serde_json",
@@ -10256,7 +10174,7 @@ dependencies = [
 "num-traits",
 "range-map",
 "scroll",
- "smart-default 0.7.1",
+ "smart-default",
 ]

 [[package]]
@@ -11148,14 +11066,13 @@ dependencies = [
 "ai_onboarding",
 "anyhow",
 "client",
- "command_palette_hooks",
 "component",
 "db",
 "documented",
 "editor",
- "feature_flags",
 "fs",
 "fuzzy",
+ "git",
 "gpui",
 "itertools 0.14.0",
 "language",
@@ -11167,6 +11084,7 @@ dependencies = [
 "schemars",
 "serde",
 "settings",
+ "telemetry",
 "theme",
 "ui",
 "util",
@@ -11242,6 +11160,7 @@ dependencies = [
 "anyhow",
 "futures 0.3.31",
 "http_client",
+ "log",
 "schemars",
 "serde",
 "serde_json",
@@ -13129,19 +13048,6 @@ version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"

-[[package]]
-name = "rand"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
-dependencies = [
- "getrandom 0.1.16",
- "libc",
- "rand_chacha 0.2.2",
- "rand_core 0.5.1",
- "rand_hc",
-]
-
 [[package]]
 name = "rand"
 version = "0.8.5"
@@ -13163,16 +13069,6 @@ dependencies = [
 "rand_core 0.9.3",
 ]

-[[package]]
-name = "rand_chacha"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
-dependencies = [
- "ppv-lite86",
- "rand_core 0.5.1",
-]
-
 [[package]]
 name = "rand_chacha"
 version = "0.3.1"
@@ -13193,15 +13089,6 @@ dependencies = [
 "rand_core 0.9.3",
 ]

-[[package]]
-name = "rand_core"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
-dependencies = [
- "getrandom 0.1.16",
-]
-
 [[package]]
 name = "rand_core"
 version = "0.6.4"
@@ -13220,15 +13107,6 @@ dependencies = [
 "getrandom 0.3.2",
 ]

-[[package]]
-name = "rand_hc"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
-dependencies = [
- "rand_core 0.5.1",
-]
-
 [[package]]
 name = "range-map"
 version = "0.2.0"
@@ -13963,6 +13841,7 @@ checksum = "e40ecf59e742e03336be6a3d53755e789fd05a059fa22dfa0ed624722319e183"
 dependencies = [
 "cpal",
 "dasp_sample",
+ "hound",
 "num-rational",
 "symphonia",
 "tracing",
@@ -14882,28 +14761,6 @@ dependencies = [
 "serde",
 ]

-[[package]]
-name = "serde_qs"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7715380eec75f029a4ef7de39a9200e0a63823176b759d055b613f5a87df6a6"
-dependencies = [
- "percent-encoding",
- "serde",
- "thiserror 1.0.69",
-]
-
-[[package]]
-name = "serde_qs"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8cac3f1e2ca2fe333923a1ae72caca910b98ed0630bb35ef6f8c8517d6e81afa"
-dependencies = [
- "percent-encoding",
- "serde",
- "thiserror 1.0.69",
-]
-
 [[package]]
 name = "serde_repr"
 version = "0.1.20"
@@ -15045,8 +14902,10 @@ dependencies = [
 "ui",
 "ui_input",
 "util",
+ "vim",
 "workspace",
 "workspace-hack",
+ "zed_actions",
 ]

 [[package]]
@@ -15278,17 +15137,6 @@ dependencies = [
 "serde",
 ]

-[[package]]
-name = "smart-default"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "133659a15339456eeeb07572eb02a91c91e9815e9cbc89566944d2c8d3efdbf6"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
 [[package]]
 name = "smart-default"
 version = "0.7.1"
@@ -15317,15 +15165,6 @@ dependencies = [
 "futures-lite 2.6.0",
 ]

-[[package]]
-name = "smol_str"
-version = "0.1.24"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fad6c857cbab2627dcf01ec85a623ca4e7dcb5691cbaa3d7fb7653671f0d09c9"
-dependencies = [
- "serde",
-]
-
 [[package]]
 name = "smol_str"
 version = "0.2.2"
@@ -18174,12 +18013,6 @@ dependencies = [
 "tracing",
 ]

-[[package]]
-name = "wasi"
-version = "0.9.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
-
 [[package]]
 name = "wasi"
 version = "0.11.0+wasi-snapshot-preview1"
@@ -18881,33 +18714,6 @@ version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "53a85b86a771b1c87058196170769dd264f66c0782acf1ae6cc51bfd64b39082"

-[[package]]
-name = "welcome"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "client",
- "component",
- "db",
- "documented",
- "editor",
- "fuzzy",
- "gpui",
- "install_cli",
- "language",
- "picker",
- "project",
- "serde",
- "settings",
- "telemetry",
- "ui",
- "util",
- "vim_mode_setting",
- "workspace",
- "workspace-hack",
- "zed_actions",
-]
-
 [[package]]
 name = "which"
 version = "4.4.2"
@@ -20293,7 +20099,7 @@ dependencies = [
 [[package]]
 name = "xim"
 version = "0.4.0"
-source = "git+https://github.com/XDeme1/xim-rs?rev=d50d461764c2213655cd9cf65a0ea94c70d3c4fd#d50d461764c2213655cd9cf65a0ea94c70d3c4fd"
+source = "git+https://github.com/zed-industries/xim-rs?rev=c0a70c1bd2ce197364216e5e818a2cb3adb99a8d#c0a70c1bd2ce197364216e5e818a2cb3adb99a8d"
 dependencies = [
 "ahash 0.8.11",
 "hashbrown 0.14.5",
@@ -20306,7 +20112,7 @@ dependencies = [
 [[package]]
 name = "xim-ctext"
 version = "0.3.0"
-source = "git+https://github.com/XDeme1/xim-rs?rev=d50d461764c2213655cd9cf65a0ea94c70d3c4fd#d50d461764c2213655cd9cf65a0ea94c70d3c4fd"
+source = "git+https://github.com/zed-industries/xim-rs?rev=c0a70c1bd2ce197364216e5e818a2cb3adb99a8d#c0a70c1bd2ce197364216e5e818a2cb3adb99a8d"
 dependencies = [
 "encoding_rs",
 ]
@@ -20314,7 +20120,7 @@ dependencies = [
 [[package]]
 name = "xim-parser"
 version = "0.2.1"
-source = "git+https://github.com/XDeme1/xim-rs?rev=d50d461764c2213655cd9cf65a0ea94c70d3c4fd#d50d461764c2213655cd9cf65a0ea94c70d3c4fd"
+source = "git+https://github.com/zed-industries/xim-rs?rev=c0a70c1bd2ce197364216e5e818a2cb3adb99a8d#c0a70c1bd2ce197364216e5e818a2cb3adb99a8d"
 dependencies = [
 "bitflags 2.9.0",
 ]
@@ -20522,7 +20328,7 @@ dependencies = [

 [[package]]
 name = "zed"
-version = "0.200.0"
+version = "0.201.0"
 dependencies = [
 "activity_indicator",
 "agent",
@@ -20592,6 +20398,7 @@ dependencies = [
 "language_tools",
 "languages",
 "libc",
+ "livekit_client",
 "log",
 "markdown",
 "markdown_preview",
@@ -20662,7 +20469,6 @@ dependencies = [
 "watch",
 "web_search",
 "web_search_providers",
- "welcome",
 "windows 0.61.1",
 "winresource",
 "workspace",
@@ -20684,13 +20490,6 @@ dependencies = [
 "workspace-hack",
 ]

-[[package]]
-name = "zed_emmet"
-version = "0.0.4"
-dependencies = [
- "zed_extension_api 0.1.0",
-]
-
 [[package]]
 name = "zed_extension_api"
 version = "0.1.0"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -81,7 +81,6 @@ members = [
    "crates/http_client_tls",
    "crates/icons",
    "crates/image_viewer",
-    "crates/indexed_docs",
    "crates/edit_prediction",
    "crates/edit_prediction_button",
    "crates/inspector_ui",
@@ -185,7 +184,6 @@ members = [
    "crates/watch",
    "crates/web_search",
    "crates/web_search_providers",
-    "crates/welcome",
    "crates/workspace",
    "crates/worktree",
    "crates/x_ai",
@@ -200,7 +198,6 @@ members = [
    # Extensions
    #

-    "extensions/emmet",
    "extensions/glsl",
    "extensions/html",
    "extensions/proto",
@@ -307,7 +304,6 @@ http_client = { path = "crates/http_client" }
 http_client_tls = { path = "crates/http_client_tls" }
 icons = { path = "crates/icons" }
 image_viewer = { path = "crates/image_viewer" }
-indexed_docs = { path = "crates/indexed_docs" }
 edit_prediction = { path = "crates/edit_prediction" }
 edit_prediction_button = { path = "crates/edit_prediction_button" }
 inspector_ui = { path = "crates/inspector_ui" }
@@ -364,6 +360,7 @@ remote_server = { path = "crates/remote_server" }
 repl = { path = "crates/repl" }
 reqwest_client = { path = "crates/reqwest_client" }
 rich_text = { path = "crates/rich_text" }
+rodio = { version = "0.21.1", default-features = false }
 rope = { path = "crates/rope" }
 rpc = { path = "crates/rpc" }
 rules_library = { path = "crates/rules_library" }
@@ -412,7 +409,6 @@ vim_mode_setting = { path = "crates/vim_mode_setting" }
 watch = { path = "crates/watch" }
 web_search = { path = "crates/web_search" }
 web_search_providers = { path = "crates/web_search_providers" }
-welcome = { path = "crates/welcome" }
 workspace = { path = "crates/workspace" }
 worktree = { path = "crates/worktree" }
 x_ai = { path = "crates/x_ai" }
@@ -427,7 +423,7 @@ zlog_settings = { path = "crates/zlog_settings" }
 #

 agentic-coding-protocol = "0.0.10"
-agent-client-protocol = "0.0.23"
+agent-client-protocol = "0.0.25"
 aho-corasick = "1.1"
 alacritty_terminal = { git = "https://github.com/zed-industries/alacritty.git", branch = "add-hush-login-flag" }
 any_vec = "0.14"
@@ -668,20 +664,6 @@ workspace-hack = "0.1.0"
 yawc = { git = "https://github.com/deviant-forks/yawc", rev = "1899688f3e69ace4545aceb97b2a13881cf26142" }
 zstd = "0.11"

-[workspace.dependencies.async-stripe]
-git = "https://github.com/zed-industries/async-stripe"
-rev = "3672dd4efb7181aa597bf580bf5a2f5d23db6735"
-default-features = false
-features = [
-    "runtime-tokio-hyper-rustls",
-    "billing",
-    "checkout",
-    "events",
-    # The features below are only enabled to get the `events` feature to build.
-    "chrono",
-    "connect",
-]
-
 [workspace.dependencies.windows]
 version = "0.61"
 features = [
@@ -714,6 +696,7 @@ features = [
    "Win32_System_LibraryLoader",
    "Win32_System_Memory",
    "Win32_System_Ole",
+    "Win32_System_Performance",
    "Win32_System_Pipes",
    "Win32_System_SystemInformation",
    "Win32_System_SystemServices",
--- a/assets/fonts/ibm-plex-sans/IBMPlexSans-Bold.ttf
+++ b/assets/fonts/ibm-plex-sans/IBMPlexSans-Bold.ttf
--- a/assets/fonts/ibm-plex-sans/IBMPlexSans-BoldItalic.ttf
+++ b/assets/fonts/ibm-plex-sans/IBMPlexSans-BoldItalic.ttf
--- a/assets/fonts/ibm-plex-sans/IBMPlexSans-Italic.ttf
+++ b/assets/fonts/ibm-plex-sans/IBMPlexSans-Italic.ttf
--- a/assets/fonts/ibm-plex-sans/IBMPlexSans-Regular.ttf
+++ b/assets/fonts/ibm-plex-sans/IBMPlexSans-Regular.ttf
--- a/assets/fonts/ibm-plex-sans/license.txt
+++ b/assets/fonts/ibm-plex-sans/license.txt
--- a/assets/fonts/lilex/Lilex-Bold.ttf
+++ b/assets/fonts/lilex/Lilex-Bold.ttf
--- a/assets/fonts/lilex/Lilex-BoldItalic.ttf
+++ b/assets/fonts/lilex/Lilex-BoldItalic.ttf
--- a/assets/fonts/lilex/Lilex-Italic.ttf
+++ b/assets/fonts/lilex/Lilex-Italic.ttf
--- a/assets/fonts/lilex/Lilex-Regular.ttf
+++ b/assets/fonts/lilex/Lilex-Regular.ttf
--- a/assets/fonts/plex-sans/license.txt
+++ b/assets/fonts/plex-sans/license.txt
@@ -1,8 +1,9 @@
-Copyright © 2017 IBM Corp. with Reserved Font Name "Plex"
+Copyright 2019 The Lilex Project Authors (https://github.com/mishamyrt/Lilex)

 This Font Software is licensed under the SIL Open Font License, Version 1.1.
 This license is copied below, and is also available with a FAQ at:
-http://scripts.sil.org/OFL
+https://scripts.sil.org/OFL
+

 -----------------------------------------------------------
 SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
@@ -89,4 +90,4 @@ COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
 DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
-OTHER DEALINGS IN THE FONT SOFTWARE.
+OTHER DEALINGS IN THE FONT SOFTWARE.
--- a/assets/fonts/plex-mono/ZedPlexMono-Bold.ttf
+++ b/assets/fonts/plex-mono/ZedPlexMono-Bold.ttf
--- a/assets/fonts/plex-mono/ZedPlexMono-BoldItalic.ttf
+++ b/assets/fonts/plex-mono/ZedPlexMono-BoldItalic.ttf
--- a/assets/fonts/plex-mono/ZedPlexMono-Italic.ttf
+++ b/assets/fonts/plex-mono/ZedPlexMono-Italic.ttf
--- a/assets/fonts/plex-mono/ZedPlexMono-Regular.ttf
+++ b/assets/fonts/plex-mono/ZedPlexMono-Regular.ttf
--- a/assets/fonts/plex-sans/ZedPlexSans-Bold.ttf
+++ b/assets/fonts/plex-sans/ZedPlexSans-Bold.ttf
--- a/assets/fonts/plex-sans/ZedPlexSans-BoldItalic.ttf
+++ b/assets/fonts/plex-sans/ZedPlexSans-BoldItalic.ttf
--- a/assets/fonts/plex-sans/ZedPlexSans-Italic.ttf
+++ b/assets/fonts/plex-sans/ZedPlexSans-Italic.ttf
--- a/assets/fonts/plex-sans/ZedPlexSans-Regular.ttf
+++ b/assets/fonts/plex-sans/ZedPlexSans-Regular.ttf
--- a/assets/icons/json.svg
+++ b/assets/icons/json.svg
@@ -0,0 +1,4 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M5.78125 3C3.90625 3 3.90625 4.5 3.90625 5.5C3.90625 6.5 3.40625 7.50106 2.40625 8C3.40625 8.50106 3.90625 9.5 3.90625 10.5C3.90625 11.5 3.90625 13 5.78125 13" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M10.2422 3C12.1172 3 12.1172 4.5 12.1172 5.5C12.1172 6.5 12.6172 7.50106 13.6172 8C12.6172 8.50106 12.1172 9.5 12.1172 10.5C12.1172 11.5 12.1172 13 10.2422 13" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -239,6 +239,7 @@
      "ctrl-shift-a": "agent::ToggleContextPicker",
      "ctrl-shift-j": "agent::ToggleNavigationMenu",
      "ctrl-shift-i": "agent::ToggleOptionsMenu",
+      "ctrl-alt-shift-n": "agent::ToggleNewThreadMenu",
      "shift-alt-escape": "agent::ExpandMessageEditor",
      "ctrl->": "assistant::QuoteSelection",
      "ctrl-alt-e": "agent::RemoveAllContext",
@@ -330,8 +331,6 @@
    "use_key_equivalents": true,
    "bindings": {
      "enter": "agent::Chat",
-      "up": "agent::PreviousHistoryMessage",
-      "down": "agent::NextHistoryMessage",
      "shift-ctrl-r": "agent::OpenAgentDiff",
      "ctrl-shift-y": "agent::KeepAll",
      "ctrl-shift-n": "agent::RejectAll"
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -279,6 +279,7 @@
      "cmd-shift-a": "agent::ToggleContextPicker",
      "cmd-shift-j": "agent::ToggleNavigationMenu",
      "cmd-shift-i": "agent::ToggleOptionsMenu",
+      "cmd-alt-shift-n": "agent::ToggleNewThreadMenu",
      "shift-alt-escape": "agent::ExpandMessageEditor",
      "cmd->": "assistant::QuoteSelection",
      "cmd-alt-e": "agent::RemoveAllContext",
@@ -382,8 +383,6 @@
    "use_key_equivalents": true,
    "bindings": {
      "enter": "agent::Chat",
-      "up": "agent::PreviousHistoryMessage",
-      "down": "agent::NextHistoryMessage",
      "shift-ctrl-r": "agent::OpenAgentDiff",
      "cmd-shift-y": "agent::KeepAll",
      "cmd-shift-n": "agent::RejectAll"
--- a/assets/keymaps/vim.json
+++ b/assets/keymaps/vim.json
@@ -58,6 +58,8 @@
      "[ space": "vim::InsertEmptyLineAbove",
      "[ e": "editor::MoveLineUp",
      "] e": "editor::MoveLineDown",
+      "[ f": "workspace::FollowNextCollaborator",
+      "] f": "workspace::FollowNextCollaborator",

      // Word motions
      "w": "vim::NextWordStart",
@@ -390,7 +392,7 @@
      "right": "vim::WrappingRight",
      "h": "vim::WrappingLeft",
      "l": "vim::WrappingRight",
-      "y": "editor::Copy",
+      "y": "vim::HelixYank",
      "alt-;": "vim::OtherEnd",
      "ctrl-r": "vim::Redo",
      "f": ["vim::PushFindForward", { "before": false, "multiline": true }],
@@ -407,6 +409,7 @@
      "g w": "vim::PushRewrap",
      "insert": "vim::InsertBefore",
      "alt-.": "vim::RepeatFind",
+      "alt-s": ["editor::SplitSelectionIntoLines", { "keep_selections": true }],
      // tree-sitter related commands
      "[ x": "editor::SelectLargerSyntaxNode",
      "] x": "editor::SelectSmallerSyntaxNode",
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -28,7 +28,9 @@
    "edit_prediction_provider": "zed"
  },
  // The name of a font to use for rendering text in the editor
-  "buffer_font_family": "Zed Plex Mono",
+  // ".ZedMono" currently aliases to Lilex
+  // but this may change in the future.
+  "buffer_font_family": ".ZedMono",
  // Set the buffer text's font fallbacks, this will be merged with
  // the platform's default fallbacks.
  "buffer_font_fallbacks": null,
@@ -54,7 +56,9 @@
  "buffer_line_height": "comfortable",
  // The name of a font to use for rendering text in the UI
  // You can set this to ".SystemUIFont" to use the system font
-  "ui_font_family": "Zed Plex Sans",
+  // ".ZedSans" currently aliases to "IBM Plex Sans", but this may
+  // change in the future
+  "ui_font_family": ".ZedSans",
  // Set the UI's font fallbacks, this will be merged with the platform's
  // default font fallbacks.
  "ui_font_fallbacks": null,
@@ -67,8 +71,8 @@
  "ui_font_weight": 400,
  // The default font size for text in the UI
  "ui_font_size": 16,
-  // The default font size for text in the agent panel
-  "agent_font_size": 16,
+  // The default font size for text in the agent panel. Falls back to the UI font size if unset.
+  "agent_font_size": null,
  // How much to fade out unused code.
  "unnecessary_code_fade": 0.3,
  // Active pane styling settings.
@@ -82,10 +86,10 @@
  // Layout mode of the bottom dock. Defaults to "contained"
  //   choices: contained, full, left_aligned, right_aligned
  "bottom_dock_layout": "contained",
-  // The direction that you want to split panes horizontally. Defaults to "up"
-  "pane_split_direction_horizontal": "up",
-  // The direction that you want to split panes vertically. Defaults to "left"
-  "pane_split_direction_vertical": "left",
+  // The direction that you want to split panes horizontally. Defaults to "down"
+  "pane_split_direction_horizontal": "down",
+  // The direction that you want to split panes vertically. Defaults to "right"
+  "pane_split_direction_vertical": "right",
  // Centered layout related settings.
  "centered_layout": {
    // The relative width of the left padding of the central pane from the
@@ -883,11 +887,6 @@
  },
  // The settings for slash commands.
  "slash_commands": {
-    // Settings for the `/docs` slash command.
-    "docs": {
-      // Whether `/docs` is enabled.
-      "enabled": false
-    },
    // Settings for the `/project` slash command.
    "project": {
      // Whether `/project` is enabled.
@@ -1252,7 +1251,9 @@
  // Status bar-related settings.
  "status_bar": {
    // Whether to show the active language button in the status bar.
-    "active_language_button": true
+    "active_language_button": true,
+    // Whether to show the cursor position button in the status bar.
+    "cursor_position_button": true
  },
  // Settings specific to the terminal
  "terminal": {
@@ -1402,7 +1403,7 @@
    // "font_size": 15,
    // Set the terminal's font family. If this option is not included,
    // the terminal will default to matching the buffer's font family.
-    // "font_family": "Zed Plex Mono",
+    // "font_family": ".ZedMono",
    // Set the terminal's font fallbacks. If this option is not included,
    // the terminal will default to matching the buffer's font fallbacks.
    // This will be merged with the platform's default font fallbacks
--- a/crates/acp_thread/Cargo.toml
+++ b/crates/acp_thread/Cargo.toml
@@ -13,21 +13,25 @@ path = "src/acp_thread.rs"
 doctest = false

 [features]
-test-support = ["gpui/test-support", "project/test-support"]
+test-support = ["gpui/test-support", "project/test-support", "dep:parking_lot"]

 [dependencies]
 action_log.workspace = true
 agent-client-protocol.workspace = true
+agent.workspace = true
 anyhow.workspace = true
 buffer_diff.workspace = true
+collections.workspace = true
 editor.workspace = true
+file_icons.workspace = true
 futures.workspace = true
 gpui.workspace = true
 itertools.workspace = true
 language.workspace = true
-language_model.workspace = true
 markdown.workspace = true
+parking_lot = { workspace = true, optional = true }
 project.workspace = true
+prompt_store.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 settings.workspace = true
@@ -36,6 +40,8 @@ terminal.workspace = true
 ui.workspace = true
 url.workspace = true
 util.workspace = true
+uuid.workspace = true
+watch.workspace = true
 workspace-hack.workspace = true

 [dev-dependencies]
--- a/crates/acp_thread/src/acp_thread.rs
+++ b/crates/acp_thread/src/acp_thread.rs
--- a/crates/acp_thread/src/connection.rs
+++ b/crates/acp_thread/src/connection.rs
@@ -1,18 +1,98 @@
-use std::{error::Error, fmt, path::Path, rc::Rc, sync::Arc};
-
+use crate::AcpThread;
 use agent_client_protocol::{self as acp};
 use anyhow::Result;
-use gpui::{AsyncApp, Entity, Task};
-use language_model::LanguageModel;
+use collections::IndexMap;
+use gpui::{Entity, SharedString, Task};
 use project::Project;
-use ui::App;
+use std::{any::Any, error::Error, fmt, path::Path, rc::Rc, sync::Arc};
+use ui::{App, IconName};
+use uuid::Uuid;

-use crate::AcpThread;
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct UserMessageId(Arc<str>);
+
+impl UserMessageId {
+    pub fn new() -> Self {
+        Self(Uuid::new_v4().to_string().into())
+    }
+}
+
+pub trait AgentConnection {
+    fn new_thread(
+        self: Rc<Self>,
+        project: Entity<Project>,
+        cwd: &Path,
+        cx: &mut App,
+    ) -> Task<Result<Entity<AcpThread>>>;
+
+    fn auth_methods(&self) -> &[acp::AuthMethod];
+
+    fn authenticate(&self, method: acp::AuthMethodId, cx: &mut App) -> Task<Result<()>>;
+
+    fn prompt(
+        &self,
+        user_message_id: Option<UserMessageId>,
+        params: acp::PromptRequest,
+        cx: &mut App,
+    ) -> Task<Result<acp::PromptResponse>>;
+
+    fn resume(
+        &self,
+        _session_id: &acp::SessionId,
+        _cx: &mut App,
+    ) -> Option<Rc<dyn AgentSessionResume>> {
+        None
+    }
+
+    fn cancel(&self, session_id: &acp::SessionId, cx: &mut App);
+
+    fn session_editor(
+        &self,
+        _session_id: &acp::SessionId,
+        _cx: &mut App,
+    ) -> Option<Rc<dyn AgentSessionEditor>> {
+        None
+    }
+
+    /// Returns this agent as an [Rc<dyn ModelSelector>] if the model selection capability is supported.
+    ///
+    /// If the agent does not support model selection, returns [None].
+    /// This allows sharing the selector in UI components.
+    fn model_selector(&self) -> Option<Rc<dyn AgentModelSelector>> {
+        None
+    }
+
+    fn into_any(self: Rc<Self>) -> Rc<dyn Any>;
+}
+
+impl dyn AgentConnection {
+    pub fn downcast<T: 'static + AgentConnection + Sized>(self: Rc<Self>) -> Option<Rc<T>> {
+        self.into_any().downcast().ok()
+    }
+}
+
+pub trait AgentSessionEditor {
+    fn truncate(&self, message_id: UserMessageId, cx: &mut App) -> Task<Result<()>>;
+}
+
+pub trait AgentSessionResume {
+    fn run(&self, cx: &mut App) -> Task<Result<acp::PromptResponse>>;
+}
+
+#[derive(Debug)]
+pub struct AuthRequired;
+
+impl Error for AuthRequired {}
+impl fmt::Display for AuthRequired {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "AuthRequired")
+    }
+}

 /// Trait for agents that support listing, selecting, and querying language models.
 ///
 /// This is an optional capability; agents indicate support via [AgentConnection::model_selector].
-pub trait ModelSelector: 'static {
+pub trait AgentModelSelector: 'static {
    /// Lists all available language models for this agent.
    ///
    /// # Parameters
@@ -20,7 +100,7 @@ pub trait ModelSelector: 'static {
    ///
    /// # Returns
    /// A task resolving to the list of models or an error (e.g., if no models are configured).
-    fn list_models(&self, cx: &mut AsyncApp) -> Task<Result<Vec<Arc<dyn LanguageModel>>>>;
+    fn list_models(&self, cx: &mut App) -> Task<Result<AgentModelList>>;

    /// Selects a model for a specific session (thread).
    ///
@@ -37,8 +117,8 @@ pub trait ModelSelector: 'static {
    fn select_model(
        &self,
        session_id: acp::SessionId,
-        model: Arc<dyn LanguageModel>,
-        cx: &mut AsyncApp,
+        model_id: AgentModelId,
+        cx: &mut App,
    ) -> Task<Result<()>>;

    /// Retrieves the currently selected model for a specific session (thread).
@@ -52,42 +132,207 @@ pub trait ModelSelector: 'static {
    fn selected_model(
        &self,
        session_id: &acp::SessionId,
-        cx: &mut AsyncApp,
-    ) -> Task<Result<Arc<dyn LanguageModel>>>;
+        cx: &mut App,
+    ) -> Task<Result<AgentModelInfo>>;
+
+    /// Whenever the model list is updated the receiver will be notified.
+    fn watch(&self, cx: &mut App) -> watch::Receiver<()>;
 }

-pub trait AgentConnection {
-    fn new_thread(
-        self: Rc<Self>,
-        project: Entity<Project>,
-        cwd: &Path,
-        cx: &mut AsyncApp,
-    ) -> Task<Result<Entity<AcpThread>>>;
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct AgentModelId(pub SharedString);

-    fn auth_methods(&self) -> &[acp::AuthMethod];
+impl std::ops::Deref for AgentModelId {
+    type Target = SharedString;

-    fn authenticate(&self, method: acp::AuthMethodId, cx: &mut App) -> Task<Result<()>>;
-
-    fn prompt(&self, params: acp::PromptRequest, cx: &mut App)
-    -> Task<Result<acp::PromptResponse>>;
-
-    fn cancel(&self, session_id: &acp::SessionId, cx: &mut App);
-
-    /// Returns this agent as an [Rc<dyn ModelSelector>] if the model selection capability is supported.
-    ///
-    /// If the agent does not support model selection, returns [None].
-    /// This allows sharing the selector in UI components.
-    fn model_selector(&self) -> Option<Rc<dyn ModelSelector>> {
-        None // Default impl for agents that don't support it
+    fn deref(&self) -> &Self::Target {
+        &self.0
    }
 }

-#[derive(Debug)]
-pub struct AuthRequired;
-
-impl Error for AuthRequired {}
-impl fmt::Display for AuthRequired {
+impl fmt::Display for AgentModelId {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "AuthRequired")
+        self.0.fmt(f)
    }
 }
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct AgentModelInfo {
+    pub id: AgentModelId,
+    pub name: SharedString,
+    pub icon: Option<IconName>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct AgentModelGroupName(pub SharedString);
+
+#[derive(Debug, Clone)]
+pub enum AgentModelList {
+    Flat(Vec<AgentModelInfo>),
+    Grouped(IndexMap<AgentModelGroupName, Vec<AgentModelInfo>>),
+}
+
+impl AgentModelList {
+    pub fn is_empty(&self) -> bool {
+        match self {
+            AgentModelList::Flat(models) => models.is_empty(),
+            AgentModelList::Grouped(groups) => groups.is_empty(),
+        }
+    }
+}
+
+#[cfg(feature = "test-support")]
+mod test_support {
+    use std::sync::Arc;
+
+    use collections::HashMap;
+    use futures::future::try_join_all;
+    use gpui::{AppContext as _, WeakEntity};
+    use parking_lot::Mutex;
+
+    use super::*;
+
+    #[derive(Clone, Default)]
+    pub struct StubAgentConnection {
+        sessions: Arc<Mutex<HashMap<acp::SessionId, WeakEntity<AcpThread>>>>,
+        permission_requests: HashMap<acp::ToolCallId, Vec<acp::PermissionOption>>,
+        next_prompt_updates: Arc<Mutex<Vec<acp::SessionUpdate>>>,
+    }
+
+    impl StubAgentConnection {
+        pub fn new() -> Self {
+            Self {
+                next_prompt_updates: Default::default(),
+                permission_requests: HashMap::default(),
+                sessions: Arc::default(),
+            }
+        }
+
+        pub fn set_next_prompt_updates(&self, updates: Vec<acp::SessionUpdate>) {
+            *self.next_prompt_updates.lock() = updates;
+        }
+
+        pub fn with_permission_requests(
+            mut self,
+            permission_requests: HashMap<acp::ToolCallId, Vec<acp::PermissionOption>>,
+        ) -> Self {
+            self.permission_requests = permission_requests;
+            self
+        }
+
+        pub fn send_update(
+            &self,
+            session_id: acp::SessionId,
+            update: acp::SessionUpdate,
+            cx: &mut App,
+        ) {
+            self.sessions
+                .lock()
+                .get(&session_id)
+                .unwrap()
+                .update(cx, |thread, cx| {
+                    thread.handle_session_update(update.clone(), cx).unwrap();
+                })
+                .unwrap();
+        }
+    }
+
+    impl AgentConnection for StubAgentConnection {
+        fn auth_methods(&self) -> &[acp::AuthMethod] {
+            &[]
+        }
+
+        fn new_thread(
+            self: Rc<Self>,
+            project: Entity<Project>,
+            _cwd: &Path,
+            cx: &mut gpui::App,
+        ) -> Task<gpui::Result<Entity<AcpThread>>> {
+            let session_id = acp::SessionId(self.sessions.lock().len().to_string().into());
+            let thread =
+                cx.new(|cx| AcpThread::new("Test", self.clone(), project, session_id.clone(), cx));
+            self.sessions.lock().insert(session_id, thread.downgrade());
+            Task::ready(Ok(thread))
+        }
+
+        fn authenticate(
+            &self,
+            _method_id: acp::AuthMethodId,
+            _cx: &mut App,
+        ) -> Task<gpui::Result<()>> {
+            unimplemented!()
+        }
+
+        fn prompt(
+            &self,
+            _id: Option<UserMessageId>,
+            params: acp::PromptRequest,
+            cx: &mut App,
+        ) -> Task<gpui::Result<acp::PromptResponse>> {
+            let sessions = self.sessions.lock();
+            let thread = sessions.get(&params.session_id).unwrap();
+            let mut tasks = vec![];
+            for update in self.next_prompt_updates.lock().drain(..) {
+                let thread = thread.clone();
+                let update = update.clone();
+                let permission_request = if let acp::SessionUpdate::ToolCall(tool_call) = &update
+                    && let Some(options) = self.permission_requests.get(&tool_call.id)
+                {
+                    Some((tool_call.clone(), options.clone()))
+                } else {
+                    None
+                };
+                let task = cx.spawn(async move |cx| {
+                    if let Some((tool_call, options)) = permission_request {
+                        let permission = thread.update(cx, |thread, cx| {
+                            thread.request_tool_call_authorization(
+                                tool_call.clone().into(),
+                                options.clone(),
+                                cx,
+                            )
+                        })?;
+                        permission?.await?;
+                    }
+                    thread.update(cx, |thread, cx| {
+                        thread.handle_session_update(update.clone(), cx).unwrap();
+                    })?;
+                    anyhow::Ok(())
+                });
+                tasks.push(task);
+            }
+            cx.spawn(async move |_| {
+                try_join_all(tasks).await?;
+                Ok(acp::PromptResponse {
+                    stop_reason: acp::StopReason::EndTurn,
+                })
+            })
+        }
+
+        fn cancel(&self, _session_id: &acp::SessionId, _cx: &mut App) {
+            unimplemented!()
+        }
+
+        fn session_editor(
+            &self,
+            _session_id: &agent_client_protocol::SessionId,
+            _cx: &mut App,
+        ) -> Option<Rc<dyn AgentSessionEditor>> {
+            Some(Rc::new(StubAgentSessionEditor))
+        }
+
+        fn into_any(self: Rc<Self>) -> Rc<dyn Any> {
+            self
+        }
+    }
+
+    struct StubAgentSessionEditor;
+
+    impl AgentSessionEditor for StubAgentSessionEditor {
+        fn truncate(&self, _: UserMessageId, _: &mut App) -> Task<Result<()>> {
+            Task::ready(Ok(()))
+        }
+    }
+}
+
+#[cfg(feature = "test-support")]
+pub use test_support::*;
--- a/crates/acp_thread/src/mention.rs
+++ b/crates/acp_thread/src/mention.rs
@@ -1,13 +1,46 @@
-use agent_client_protocol as acp;
-use anyhow::{Result, bail};
-use std::path::PathBuf;
+use agent::ThreadId;
+use anyhow::{Context as _, Result, bail};
+use file_icons::FileIcons;
+use prompt_store::{PromptId, UserPromptId};
+use std::{
+    fmt,
+    ops::Range,
+    path::{Path, PathBuf},
+    str::FromStr,
+};
+use ui::{App, IconName, SharedString};
+use url::Url;

 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum MentionUri {
-    File(PathBuf),
-    Symbol(PathBuf, String),
-    Thread(acp::SessionId),
-    Rule(String),
+    File {
+        abs_path: PathBuf,
+        is_directory: bool,
+    },
+    Symbol {
+        path: PathBuf,
+        name: String,
+        line_range: Range<u32>,
+    },
+    Thread {
+        id: ThreadId,
+        name: String,
+    },
+    TextThread {
+        path: PathBuf,
+        name: String,
+    },
+    Rule {
+        id: PromptId,
+        name: String,
+    },
+    Selection {
+        path: PathBuf,
+        line_range: Range<u32>,
+    },
+    Fetch {
+        url: Url,
+    },
 }

 impl MentionUri {
@@ -17,58 +50,219 @@ impl MentionUri {
        match url.scheme() {
            "file" => {
                if let Some(fragment) = url.fragment() {
-                    Ok(Self::Symbol(path.into(), fragment.into()))
+                    let range = fragment
+                        .strip_prefix("L")
+                        .context("Line range must start with \"L\"")?;
+                    let (start, end) = range
+                        .split_once(":")
+                        .context("Line range must use colon as separator")?;
+                    let line_range = start
+                        .parse::<u32>()
+                        .context("Parsing line range start")?
+                        .checked_sub(1)
+                        .context("Line numbers should be 1-based")?
+                        ..end
+                            .parse::<u32>()
+                            .context("Parsing line range end")?
+                            .checked_sub(1)
+                            .context("Line numbers should be 1-based")?;
+                    if let Some(name) = single_query_param(&url, "symbol")? {
+                        Ok(Self::Symbol {
+                            name,
+                            path: path.into(),
+                            line_range,
+                        })
+                    } else {
+                        Ok(Self::Selection {
+                            path: path.into(),
+                            line_range,
+                        })
+                    }
                } else {
                    let file_path =
                        PathBuf::from(format!("{}{}", url.host_str().unwrap_or(""), path));
+                    let is_directory = input.ends_with("/");

-                    Ok(Self::File(file_path))
+                    Ok(Self::File {
+                        abs_path: file_path,
+                        is_directory,
+                    })
                }
            }
            "zed" => {
-                if let Some(thread) = path.strip_prefix("/agent/thread/") {
-                    Ok(Self::Thread(acp::SessionId(thread.into())))
-                } else if let Some(rule) = path.strip_prefix("/agent/rule/") {
-                    Ok(Self::Rule(rule.into()))
+                if let Some(thread_id) = path.strip_prefix("/agent/thread/") {
+                    let name = single_query_param(&url, "name")?.context("Missing thread name")?;
+                    Ok(Self::Thread {
+                        id: thread_id.into(),
+                        name,
+                    })
+                } else if let Some(path) = path.strip_prefix("/agent/text-thread/") {
+                    let name = single_query_param(&url, "name")?.context("Missing thread name")?;
+                    Ok(Self::TextThread {
+                        path: path.into(),
+                        name,
+                    })
+                } else if let Some(rule_id) = path.strip_prefix("/agent/rule/") {
+                    let name = single_query_param(&url, "name")?.context("Missing rule name")?;
+                    let rule_id = UserPromptId(rule_id.parse()?);
+                    Ok(Self::Rule {
+                        id: rule_id.into(),
+                        name,
+                    })
                } else {
                    bail!("invalid zed url: {:?}", input);
                }
            }
+            "http" | "https" => Ok(MentionUri::Fetch { url }),
            other => bail!("unrecognized scheme {:?}", other),
        }
    }

    pub fn name(&self) -> String {
        match self {
-            MentionUri::File(path) => path.file_name().unwrap().to_string_lossy().into_owned(),
-            MentionUri::Symbol(_path, name) => name.clone(),
-            MentionUri::Thread(thread) => thread.to_string(),
-            MentionUri::Rule(rule) => rule.clone(),
+            MentionUri::File { abs_path, .. } => abs_path
+                .file_name()
+                .unwrap_or_default()
+                .to_string_lossy()
+                .into_owned(),
+            MentionUri::Symbol { name, .. } => name.clone(),
+            MentionUri::Thread { name, .. } => name.clone(),
+            MentionUri::TextThread { name, .. } => name.clone(),
+            MentionUri::Rule { name, .. } => name.clone(),
+            MentionUri::Selection {
+                path, line_range, ..
+            } => selection_name(path, line_range),
+            MentionUri::Fetch { url } => url.to_string(),
        }
    }

-    pub fn to_link(&self) -> String {
-        let name = self.name();
-        let uri = self.to_uri();
-        format!("[{name}]({uri})")
-    }
-
-    pub fn to_uri(&self) -> String {
+    pub fn icon_path(&self, cx: &mut App) -> SharedString {
        match self {
-            MentionUri::File(path) => {
-                format!("file://{}", path.display())
-            }
-            MentionUri::Symbol(path, name) => {
-                format!("file://{}#{}", path.display(), name)
-            }
-            MentionUri::Thread(thread) => {
-                format!("zed:///agent/thread/{}", thread.0)
-            }
-            MentionUri::Rule(rule) => {
-                format!("zed:///agent/rule/{}", rule)
+            MentionUri::File {
+                abs_path,
+                is_directory,
+            } => {
+                if *is_directory {
+                    FileIcons::get_folder_icon(false, cx)
+                        .unwrap_or_else(|| IconName::Folder.path().into())
+                } else {
+                    FileIcons::get_icon(&abs_path, cx)
+                        .unwrap_or_else(|| IconName::File.path().into())
+                }
            }
+            MentionUri::Symbol { .. } => IconName::Code.path().into(),
+            MentionUri::Thread { .. } => IconName::Thread.path().into(),
+            MentionUri::TextThread { .. } => IconName::Thread.path().into(),
+            MentionUri::Rule { .. } => IconName::Reader.path().into(),
+            MentionUri::Selection { .. } => IconName::Reader.path().into(),
+            MentionUri::Fetch { .. } => IconName::ToolWeb.path().into(),
        }
    }
+
+    pub fn as_link<'a>(&'a self) -> MentionLink<'a> {
+        MentionLink(self)
+    }
+
+    pub fn to_uri(&self) -> Url {
+        match self {
+            MentionUri::File {
+                abs_path,
+                is_directory,
+            } => {
+                let mut url = Url::parse("file:///").unwrap();
+                let mut path = abs_path.to_string_lossy().to_string();
+                if *is_directory && !path.ends_with("/") {
+                    path.push_str("/");
+                }
+                url.set_path(&path);
+                url
+            }
+            MentionUri::Symbol {
+                path,
+                name,
+                line_range,
+            } => {
+                let mut url = Url::parse("file:///").unwrap();
+                url.set_path(&path.to_string_lossy());
+                url.query_pairs_mut().append_pair("symbol", name);
+                url.set_fragment(Some(&format!(
+                    "L{}:{}",
+                    line_range.start + 1,
+                    line_range.end + 1
+                )));
+                url
+            }
+            MentionUri::Selection { path, line_range } => {
+                let mut url = Url::parse("file:///").unwrap();
+                url.set_path(&path.to_string_lossy());
+                url.set_fragment(Some(&format!(
+                    "L{}:{}",
+                    line_range.start + 1,
+                    line_range.end + 1
+                )));
+                url
+            }
+            MentionUri::Thread { name, id } => {
+                let mut url = Url::parse("zed:///").unwrap();
+                url.set_path(&format!("/agent/thread/{id}"));
+                url.query_pairs_mut().append_pair("name", name);
+                url
+            }
+            MentionUri::TextThread { path, name } => {
+                let mut url = Url::parse("zed:///").unwrap();
+                url.set_path(&format!("/agent/text-thread/{}", path.to_string_lossy()));
+                url.query_pairs_mut().append_pair("name", name);
+                url
+            }
+            MentionUri::Rule { name, id } => {
+                let mut url = Url::parse("zed:///").unwrap();
+                url.set_path(&format!("/agent/rule/{id}"));
+                url.query_pairs_mut().append_pair("name", name);
+                url
+            }
+            MentionUri::Fetch { url } => url.clone(),
+        }
+    }
+}
+
+impl FromStr for MentionUri {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> anyhow::Result<Self> {
+        Self::parse(s)
+    }
+}
+
+pub struct MentionLink<'a>(&'a MentionUri);
+
+impl fmt::Display for MentionLink<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "[@{}]({})", self.0.name(), self.0.to_uri())
+    }
+}
+
+fn single_query_param(url: &Url, name: &'static str) -> Result<Option<String>> {
+    let pairs = url.query_pairs().collect::<Vec<_>>();
+    match pairs.as_slice() {
+        [] => Ok(None),
+        [(k, v)] => {
+            if k != name {
+                bail!("invalid query parameter")
+            }
+
+            Ok(Some(v.to_string()))
+        }
+        _ => bail!("too many query pairs"),
+    }
+}
+
+pub fn selection_name(path: &Path, line_range: &Range<u32>) -> String {
+    format!(
+        "{} ({}:{})",
+        path.file_name().unwrap_or_default().display(),
+        line_range.start + 1,
+        line_range.end + 1
+    )
 }

 #[cfg(test)]
@@ -76,50 +270,191 @@ mod tests {
    use super::*;

    #[test]
-    fn test_mention_uri_parse_and_display() {
-        // Test file URI
+    fn test_parse_file_uri() {
        let file_uri = "file:///path/to/file.rs";
        let parsed = MentionUri::parse(file_uri).unwrap();
        match &parsed {
-            MentionUri::File(path) => assert_eq!(path.to_str().unwrap(), "/path/to/file.rs"),
+            MentionUri::File {
+                abs_path,
+                is_directory,
+            } => {
+                assert_eq!(abs_path.to_str().unwrap(), "/path/to/file.rs");
+                assert!(!is_directory);
+            }
            _ => panic!("Expected File variant"),
        }
-        assert_eq!(parsed.to_uri(), file_uri);
+        assert_eq!(parsed.to_uri().to_string(), file_uri);
+    }

-        // Test symbol URI
-        let symbol_uri = "file:///path/to/file.rs#MySymbol";
+    #[test]
+    fn test_parse_directory_uri() {
+        let file_uri = "file:///path/to/dir/";
+        let parsed = MentionUri::parse(file_uri).unwrap();
+        match &parsed {
+            MentionUri::File {
+                abs_path,
+                is_directory,
+            } => {
+                assert_eq!(abs_path.to_str().unwrap(), "/path/to/dir/");
+                assert!(is_directory);
+            }
+            _ => panic!("Expected File variant"),
+        }
+        assert_eq!(parsed.to_uri().to_string(), file_uri);
+    }
+
+    #[test]
+    fn test_to_directory_uri_with_slash() {
+        let uri = MentionUri::File {
+            abs_path: PathBuf::from("/path/to/dir/"),
+            is_directory: true,
+        };
+        assert_eq!(uri.to_uri().to_string(), "file:///path/to/dir/");
+    }
+
+    #[test]
+    fn test_to_directory_uri_without_slash() {
+        let uri = MentionUri::File {
+            abs_path: PathBuf::from("/path/to/dir"),
+            is_directory: true,
+        };
+        assert_eq!(uri.to_uri().to_string(), "file:///path/to/dir/");
+    }
+
+    #[test]
+    fn test_parse_symbol_uri() {
+        let symbol_uri = "file:///path/to/file.rs?symbol=MySymbol#L10:20";
        let parsed = MentionUri::parse(symbol_uri).unwrap();
        match &parsed {
-            MentionUri::Symbol(path, symbol) => {
+            MentionUri::Symbol {
+                path,
+                name,
+                line_range,
+            } => {
                assert_eq!(path.to_str().unwrap(), "/path/to/file.rs");
-                assert_eq!(symbol, "MySymbol");
+                assert_eq!(name, "MySymbol");
+                assert_eq!(line_range.start, 9);
+                assert_eq!(line_range.end, 19);
            }
            _ => panic!("Expected Symbol variant"),
        }
-        assert_eq!(parsed.to_uri(), symbol_uri);
+        assert_eq!(parsed.to_uri().to_string(), symbol_uri);
+    }

-        // Test thread URI
-        let thread_uri = "zed:///agent/thread/session123";
+    #[test]
+    fn test_parse_selection_uri() {
+        let selection_uri = "file:///path/to/file.rs#L5:15";
+        let parsed = MentionUri::parse(selection_uri).unwrap();
+        match &parsed {
+            MentionUri::Selection { path, line_range } => {
+                assert_eq!(path.to_str().unwrap(), "/path/to/file.rs");
+                assert_eq!(line_range.start, 4);
+                assert_eq!(line_range.end, 14);
+            }
+            _ => panic!("Expected Selection variant"),
+        }
+        assert_eq!(parsed.to_uri().to_string(), selection_uri);
+    }
+
+    #[test]
+    fn test_parse_thread_uri() {
+        let thread_uri = "zed:///agent/thread/session123?name=Thread+name";
        let parsed = MentionUri::parse(thread_uri).unwrap();
        match &parsed {
-            MentionUri::Thread(session_id) => assert_eq!(session_id.0.as_ref(), "session123"),
+            MentionUri::Thread {
+                id: thread_id,
+                name,
+            } => {
+                assert_eq!(thread_id.to_string(), "session123");
+                assert_eq!(name, "Thread name");
+            }
            _ => panic!("Expected Thread variant"),
        }
-        assert_eq!(parsed.to_uri(), thread_uri);
+        assert_eq!(parsed.to_uri().to_string(), thread_uri);
+    }

-        // Test rule URI
-        let rule_uri = "zed:///agent/rule/my_rule";
+    #[test]
+    fn test_parse_rule_uri() {
+        let rule_uri = "zed:///agent/rule/d8694ff2-90d5-4b6f-be33-33c1763acd52?name=Some+rule";
        let parsed = MentionUri::parse(rule_uri).unwrap();
        match &parsed {
-            MentionUri::Rule(rule) => assert_eq!(rule, "my_rule"),
+            MentionUri::Rule { id, name } => {
+                assert_eq!(id.to_string(), "d8694ff2-90d5-4b6f-be33-33c1763acd52");
+                assert_eq!(name, "Some rule");
+            }
            _ => panic!("Expected Rule variant"),
        }
-        assert_eq!(parsed.to_uri(), rule_uri);
+        assert_eq!(parsed.to_uri().to_string(), rule_uri);
+    }

-        // Test invalid scheme
-        assert!(MentionUri::parse("http://example.com").is_err());
+    #[test]
+    fn test_parse_fetch_http_uri() {
+        let http_uri = "http://example.com/path?query=value#fragment";
+        let parsed = MentionUri::parse(http_uri).unwrap();
+        match &parsed {
+            MentionUri::Fetch { url } => {
+                assert_eq!(url.to_string(), http_uri);
+            }
+            _ => panic!("Expected Fetch variant"),
+        }
+        assert_eq!(parsed.to_uri().to_string(), http_uri);
+    }

-        // Test invalid zed path
+    #[test]
+    fn test_parse_fetch_https_uri() {
+        let https_uri = "https://example.com/api/endpoint";
+        let parsed = MentionUri::parse(https_uri).unwrap();
+        match &parsed {
+            MentionUri::Fetch { url } => {
+                assert_eq!(url.to_string(), https_uri);
+            }
+            _ => panic!("Expected Fetch variant"),
+        }
+        assert_eq!(parsed.to_uri().to_string(), https_uri);
+    }
+
+    #[test]
+    fn test_invalid_scheme() {
+        assert!(MentionUri::parse("ftp://example.com").is_err());
+        assert!(MentionUri::parse("ssh://example.com").is_err());
+        assert!(MentionUri::parse("unknown://example.com").is_err());
+    }
+
+    #[test]
+    fn test_invalid_zed_path() {
        assert!(MentionUri::parse("zed:///invalid/path").is_err());
+        assert!(MentionUri::parse("zed:///agent/unknown/test").is_err());
+    }
+
+    #[test]
+    fn test_invalid_line_range_format() {
+        // Missing L prefix
+        assert!(MentionUri::parse("file:///path/to/file.rs#10:20").is_err());
+
+        // Missing colon separator
+        assert!(MentionUri::parse("file:///path/to/file.rs#L1020").is_err());
+
+        // Invalid numbers
+        assert!(MentionUri::parse("file:///path/to/file.rs#L10:abc").is_err());
+        assert!(MentionUri::parse("file:///path/to/file.rs#Labc:20").is_err());
+    }
+
+    #[test]
+    fn test_invalid_query_parameters() {
+        // Invalid query parameter name
+        assert!(MentionUri::parse("file:///path/to/file.rs#L10:20?invalid=test").is_err());
+
+        // Too many query parameters
+        assert!(
+            MentionUri::parse("file:///path/to/file.rs#L10:20?symbol=test&another=param").is_err()
+        );
+    }
+
+    #[test]
+    fn test_zero_based_line_numbers() {
+        // Test that 0-based line numbers are rejected (should be 1-based)
+        assert!(MentionUri::parse("file:///path/to/file.rs#L0:10").is_err());
+        assert!(MentionUri::parse("file:///path/to/file.rs#L1:0").is_err());
+        assert!(MentionUri::parse("file:///path/to/file.rs#L0:0").is_err());
    }
 }
--- a/crates/activity_indicator/src/activity_indicator.rs
+++ b/crates/activity_indicator/src/activity_indicator.rs
@@ -716,18 +716,10 @@ impl ActivityIndicator {
                    })),
                    tooltip_message: Some(Self::version_tooltip_message(&version)),
                }),
-                AutoUpdateStatus::Updated {
-                    binary_path,
-                    version,
-                } => Some(Content {
+                AutoUpdateStatus::Updated { version } => Some(Content {
                    icon: None,
                    message: "Click to restart and update Zed".to_string(),
-                    on_click: Some(Arc::new({
-                        let reload = workspace::Reload {
-                            binary_path: Some(binary_path.clone()),
-                        };
-                        move |_, _, cx| workspace::reload(&reload, cx)
-                    })),
+                    on_click: Some(Arc::new(move |_, _, cx| workspace::reload(cx))),
                    tooltip_message: Some(Self::version_tooltip_message(&version)),
                }),
                AutoUpdateStatus::Errored => Some(Content {
--- a/crates/agent/src/thread.rs
+++ b/crates/agent/src/thread.rs
@@ -844,11 +844,17 @@ impl Thread {
                    .await
                    .unwrap_or(false);

-                if !equal {
-                    this.update(cx, |this, cx| {
-                        this.insert_checkpoint(pending_checkpoint, cx)
-                    })?;
-                }
+                this.update(cx, |this, cx| {
+                    this.pending_checkpoint = if equal {
+                        Some(pending_checkpoint)
+                    } else {
+                        this.insert_checkpoint(pending_checkpoint, cx);
+                        Some(ThreadCheckpoint {
+                            message_id: this.next_message_id,
+                            git_checkpoint: final_checkpoint,
+                        })
+                    }
+                })?;

                Ok(())
            }
@@ -2268,6 +2274,15 @@ impl Thread {
                    max_attempts: 3,
                })
            }
+            Other(err)
+                if err.is::<PaymentRequiredError>()
+                    || err.is::<ModelRequestLimitReachedError>() =>
+            {
+                // Retrying won't help for Payment Required or Model Request Limit errors (where
+                // the user must upgrade to usage-based billing to get more requests, or else wait
+                // for a significant amount of time for the request limit to reset).
+                None
+            }
            // Conservatively assume that any other errors are non-retryable
            HttpResponseError { .. } | Other(..) => Some(RetryStrategy::Fixed {
                delay: BASE_RETRY_DELAY,
--- a/crates/agent/src/thread_store.rs
+++ b/crates/agent/src/thread_store.rs
@@ -205,6 +205,22 @@ impl ThreadStore {
        (this, ready_rx)
    }

+    #[cfg(any(test, feature = "test-support"))]
+    pub fn fake(project: Entity<Project>, cx: &mut App) -> Self {
+        Self {
+            project,
+            tools: cx.new(|_| ToolWorkingSet::default()),
+            prompt_builder: Arc::new(PromptBuilder::new(None).unwrap()),
+            prompt_store: None,
+            context_server_tool_ids: HashMap::default(),
+            threads: Vec::new(),
+            project_context: SharedProjectContext::default(),
+            reload_system_prompt_tx: mpsc::channel(0).0,
+            _reload_system_prompt_task: Task::ready(()),
+            _subscriptions: vec![],
+        }
+    }
+
    fn handle_project_event(
        &mut self,
        _project: Entity<Project>,
--- a/crates/agent2/Cargo.toml
+++ b/crates/agent2/Cargo.toml
@@ -49,6 +49,7 @@ settings.workspace = true
 smol.workspace = true
 task.workspace = true
 terminal.workspace = true
+text.workspace = true
 ui.workspace = true
 util.workspace = true
 uuid.workspace = true
--- a/crates/agent2/src/agent.rs
+++ b/crates/agent2/src/agent.rs
@@ -1,21 +1,27 @@
-use crate::{AgentResponseEvent, Thread, templates::Templates};
 use crate::{
-    ContextServerRegistry, CopyPathTool, CreateDirectoryTool, DiagnosticsTool, EditFileTool,
-    FetchTool, FindPathTool, GrepTool, ListDirectoryTool, MessageContent, MovePathTool, NowTool,
-    OpenTool, ReadFileTool, TerminalTool, ThinkingTool, ToolCallAuthorization, WebSearchTool,
+    AgentResponseEvent, ContextServerRegistry, CopyPathTool, CreateDirectoryTool, DeletePathTool,
+    DiagnosticsTool, EditFileTool, FetchTool, FindPathTool, GrepTool, ListDirectoryTool,
+    MovePathTool, NowTool, OpenTool, ReadFileTool, TerminalTool, ThinkingTool, Thread,
+    ToolCallAuthorization, UserMessageContent, WebSearchTool, templates::Templates,
 };
-use acp_thread::ModelSelector;
+use acp_thread::AgentModelSelector;
 use agent_client_protocol as acp;
+use agent_settings::AgentSettings;
 use anyhow::{Context as _, Result, anyhow};
+use collections::{HashSet, IndexMap};
+use fs::Fs;
+use futures::channel::mpsc;
 use futures::{StreamExt, future};
 use gpui::{
    App, AppContext, AsyncApp, Context, Entity, SharedString, Subscription, Task, WeakEntity,
 };
-use language_model::{LanguageModel, LanguageModelRegistry};
+use language_model::{LanguageModel, LanguageModelProvider, LanguageModelRegistry};
 use project::{Project, ProjectItem, ProjectPath, Worktree};
 use prompt_store::{
    ProjectContext, PromptId, PromptStore, RulesFileContext, UserRulesContext, WorktreeContext,
 };
+use settings::update_settings_file;
+use std::any::Any;
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::path::Path;
@@ -48,6 +54,104 @@ struct Session {
    _subscription: Subscription,
 }

+pub struct LanguageModels {
+    /// Access language model by ID
+    models: HashMap<acp_thread::AgentModelId, Arc<dyn LanguageModel>>,
+    /// Cached list for returning language model information
+    model_list: acp_thread::AgentModelList,
+    refresh_models_rx: watch::Receiver<()>,
+    refresh_models_tx: watch::Sender<()>,
+}
+
+impl LanguageModels {
+    fn new(cx: &App) -> Self {
+        let (refresh_models_tx, refresh_models_rx) = watch::channel(());
+        let mut this = Self {
+            models: HashMap::default(),
+            model_list: acp_thread::AgentModelList::Grouped(IndexMap::default()),
+            refresh_models_rx,
+            refresh_models_tx,
+        };
+        this.refresh_list(cx);
+        this
+    }
+
+    fn refresh_list(&mut self, cx: &App) {
+        let providers = LanguageModelRegistry::global(cx)
+            .read(cx)
+            .providers()
+            .into_iter()
+            .filter(|provider| provider.is_authenticated(cx))
+            .collect::<Vec<_>>();
+
+        let mut language_model_list = IndexMap::default();
+        let mut recommended_models = HashSet::default();
+
+        let mut recommended = Vec::new();
+        for provider in &providers {
+            for model in provider.recommended_models(cx) {
+                recommended_models.insert(model.id());
+                recommended.push(Self::map_language_model_to_info(&model, &provider));
+            }
+        }
+        if !recommended.is_empty() {
+            language_model_list.insert(
+                acp_thread::AgentModelGroupName("Recommended".into()),
+                recommended,
+            );
+        }
+
+        let mut models = HashMap::default();
+        for provider in providers {
+            let mut provider_models = Vec::new();
+            for model in provider.provided_models(cx) {
+                let model_info = Self::map_language_model_to_info(&model, &provider);
+                let model_id = model_info.id.clone();
+                if !recommended_models.contains(&model.id()) {
+                    provider_models.push(model_info);
+                }
+                models.insert(model_id, model);
+            }
+            if !provider_models.is_empty() {
+                language_model_list.insert(
+                    acp_thread::AgentModelGroupName(provider.name().0.clone()),
+                    provider_models,
+                );
+            }
+        }
+
+        self.models = models;
+        self.model_list = acp_thread::AgentModelList::Grouped(language_model_list);
+        self.refresh_models_tx.send(()).ok();
+    }
+
+    fn watch(&self) -> watch::Receiver<()> {
+        self.refresh_models_rx.clone()
+    }
+
+    pub fn model_from_id(
+        &self,
+        model_id: &acp_thread::AgentModelId,
+    ) -> Option<Arc<dyn LanguageModel>> {
+        self.models.get(model_id).cloned()
+    }
+
+    fn map_language_model_to_info(
+        model: &Arc<dyn LanguageModel>,
+        provider: &Arc<dyn LanguageModelProvider>,
+    ) -> acp_thread::AgentModelInfo {
+        acp_thread::AgentModelInfo {
+            id: Self::model_id(model),
+            name: model.name().0,
+            icon: Some(provider.icon()),
+        }
+    }
+
+    fn model_id(model: &Arc<dyn LanguageModel>) -> acp_thread::AgentModelId {
+        acp_thread::AgentModelId(format!("{}/{}", model.provider_id().0, model.id().0).into())
+    }
+}
+
 pub struct NativeAgent {
    /// Session ID -> Session mapping
    sessions: HashMap<acp::SessionId, Session>,
@@ -58,8 +162,11 @@ pub struct NativeAgent {
    context_server_registry: Entity<ContextServerRegistry>,
    /// Shared templates for all threads
    templates: Arc<Templates>,
+    /// Cached model information
+    models: LanguageModels,
    project: Entity<Project>,
    prompt_store: Option<Entity<PromptStore>>,
+    fs: Arc<dyn Fs>,
    _subscriptions: Vec<Subscription>,
 }

@@ -68,6 +175,7 @@ impl NativeAgent {
        project: Entity<Project>,
        templates: Arc<Templates>,
        prompt_store: Option<Entity<PromptStore>>,
+        fs: Arc<dyn Fs>,
        cx: &mut AsyncApp,
    ) -> Result<Entity<NativeAgent>> {
        log::info!("Creating new NativeAgent");
@@ -77,7 +185,13 @@ impl NativeAgent {
            .await;

        cx.new(|cx| {
-            let mut subscriptions = vec![cx.subscribe(&project, Self::handle_project_event)];
+            let mut subscriptions = vec![
+                cx.subscribe(&project, Self::handle_project_event),
+                cx.subscribe(
+                    &LanguageModelRegistry::global(cx),
+                    Self::handle_models_updated_event,
+                ),
+            ];
            if let Some(prompt_store) = prompt_store.as_ref() {
                subscriptions.push(cx.subscribe(prompt_store, Self::handle_prompts_updated_event))
            }
@@ -95,13 +209,19 @@ impl NativeAgent {
                    ContextServerRegistry::new(project.read(cx).context_server_store(), cx)
                }),
                templates,
+                models: LanguageModels::new(cx),
                project,
                prompt_store,
+                fs,
                _subscriptions: subscriptions,
            }
        })
    }

+    pub fn models(&self) -> &LanguageModels {
+        &self.models
+    }
+
    async fn maintain_project_context(
        this: WeakEntity<Self>,
        mut needs_refresh: watch::Receiver<()>,
@@ -297,241 +417,63 @@ impl NativeAgent {
    ) {
        self.project_context_needs_refresh.send(()).ok();
    }
+
+    fn handle_models_updated_event(
+        &mut self,
+        _registry: Entity<LanguageModelRegistry>,
+        _event: &language_model::Event,
+        cx: &mut Context<Self>,
+    ) {
+        self.models.refresh_list(cx);
+        for session in self.sessions.values_mut() {
+            session.thread.update(cx, |thread, _| {
+                let model_id = LanguageModels::model_id(&thread.model());
+                if let Some(model) = self.models.model_from_id(&model_id) {
+                    thread.set_model(model.clone());
+                }
+            });
+        }
+    }
 }

 /// Wrapper struct that implements the AgentConnection trait
 #[derive(Clone)]
 pub struct NativeAgentConnection(pub Entity<NativeAgent>);

-impl ModelSelector for NativeAgentConnection {
-    fn list_models(&self, cx: &mut AsyncApp) -> Task<Result<Vec<Arc<dyn LanguageModel>>>> {
-        log::debug!("NativeAgentConnection::list_models called");
-        cx.spawn(async move |cx| {
-            cx.update(|cx| {
-                let registry = LanguageModelRegistry::read_global(cx);
-                let models = registry.available_models(cx).collect::<Vec<_>>();
-                log::info!("Found {} available models", models.len());
-                if models.is_empty() {
-                    Err(anyhow::anyhow!("No models available"))
-                } else {
-                    Ok(models)
-                }
-            })?
-        })
+impl NativeAgentConnection {
+    pub fn thread(&self, session_id: &acp::SessionId, cx: &App) -> Option<Entity<Thread>> {
+        self.0
+            .read(cx)
+            .sessions
+            .get(session_id)
+            .map(|session| session.thread.clone())
    }

-    fn select_model(
+    fn run_turn(
        &self,
        session_id: acp::SessionId,
-        model: Arc<dyn LanguageModel>,
-        cx: &mut AsyncApp,
-    ) -> Task<Result<()>> {
-        log::info!(
-            "Setting model for session {}: {:?}",
-            session_id,
-            model.name()
-        );
-        let agent = self.0.clone();
-
-        cx.spawn(async move |cx| {
-            agent.update(cx, |agent, cx| {
-                if let Some(session) = agent.sessions.get(&session_id) {
-                    session.thread.update(cx, |thread, _cx| {
-                        thread.selected_model = model;
-                    });
-                    Ok(())
-                } else {
-                    Err(anyhow!("Session not found"))
-                }
-            })?
-        })
-    }
-
-    fn selected_model(
-        &self,
-        session_id: &acp::SessionId,
-        cx: &mut AsyncApp,
-    ) -> Task<Result<Arc<dyn LanguageModel>>> {
-        let agent = self.0.clone();
-        let session_id = session_id.clone();
-        cx.spawn(async move |cx| {
-            let thread = agent
-                .read_with(cx, |agent, _| {
-                    agent
-                        .sessions
-                        .get(&session_id)
-                        .map(|session| session.thread.clone())
-                })?
-                .ok_or_else(|| anyhow::anyhow!("Session not found"))?;
-            let selected = thread.read_with(cx, |thread, _| thread.selected_model.clone())?;
-            Ok(selected)
-        })
-    }
-}
-
-impl acp_thread::AgentConnection for NativeAgentConnection {
-    fn new_thread(
-        self: Rc<Self>,
-        project: Entity<Project>,
-        cwd: &Path,
-        cx: &mut AsyncApp,
-    ) -> Task<Result<Entity<acp_thread::AcpThread>>> {
-        let agent = self.0.clone();
-        log::info!("Creating new thread for project at: {:?}", cwd);
-
-        cx.spawn(async move |cx| {
-            log::debug!("Starting thread creation in async context");
-
-            // Generate session ID
-            let session_id = acp::SessionId(uuid::Uuid::new_v4().to_string().into());
-            log::info!("Created session with ID: {}", session_id);
-
-            // Create AcpThread
-            let acp_thread = cx.update(|cx| {
-                cx.new(|cx| {
-                    acp_thread::AcpThread::new(
-                        "agent2",
-                        self.clone(),
-                        project.clone(),
-                        session_id.clone(),
-                        cx,
-                    )
-                })
-            })?;
-            let action_log = cx.update(|cx| acp_thread.read(cx).action_log().clone())?;
-
-            // Create Thread
-            let thread = agent.update(
-                cx,
-                |agent, cx: &mut gpui::Context<NativeAgent>| -> Result<_> {
-                    // Fetch default model from registry settings
-                    let registry = LanguageModelRegistry::read_global(cx);
-
-                    // Log available models for debugging
-                    let available_count = registry.available_models(cx).count();
-                    log::debug!("Total available models: {}", available_count);
-
-                    let default_model = registry
-                        .default_model()
-                        .map(|configured| {
-                            log::info!(
-                                "Using configured default model: {:?} from provider: {:?}",
-                                configured.model.name(),
-                                configured.provider.name()
-                            );
-                            configured.model
-                        })
-                        .ok_or_else(|| {
-                            log::warn!("No default model configured in settings");
-                            anyhow!(
-                                "No default model. Please configure a default model in settings."
-                            )
-                        })?;
-
-                    let thread = cx.new(|cx| {
-                        let mut thread = Thread::new(
-                            project.clone(),
-                            agent.project_context.clone(),
-                            agent.context_server_registry.clone(),
-                            action_log.clone(),
-                            agent.templates.clone(),
-                            default_model,
-                            cx,
-                        );
-                        thread.add_tool(CreateDirectoryTool::new(project.clone()));
-                        thread.add_tool(CopyPathTool::new(project.clone()));
-                        thread.add_tool(DiagnosticsTool::new(project.clone()));
-                        thread.add_tool(MovePathTool::new(project.clone()));
-                        thread.add_tool(ListDirectoryTool::new(project.clone()));
-                        thread.add_tool(OpenTool::new(project.clone()));
-                        thread.add_tool(ThinkingTool);
-                        thread.add_tool(FindPathTool::new(project.clone()));
-                        thread.add_tool(FetchTool::new(project.read(cx).client().http_client()));
-                        thread.add_tool(GrepTool::new(project.clone()));
-                        thread.add_tool(ReadFileTool::new(project.clone(), action_log));
-                        thread.add_tool(EditFileTool::new(cx.entity()));
-                        thread.add_tool(NowTool);
-                        thread.add_tool(TerminalTool::new(project.clone(), cx));
-                        // TODO: Needs to be conditional based on zed model or not
-                        thread.add_tool(WebSearchTool);
-                        thread
-                    });
-
-                    Ok(thread)
-                },
-            )??;
-
-            // Store the session
-            agent.update(cx, |agent, cx| {
-                agent.sessions.insert(
-                    session_id,
-                    Session {
-                        thread,
-                        acp_thread: acp_thread.downgrade(),
-                        _subscription: cx.observe_release(&acp_thread, |this, acp_thread, _cx| {
-                            this.sessions.remove(acp_thread.session_id());
-                        }),
-                    },
-                );
-            })?;
-
-            Ok(acp_thread)
-        })
-    }
-
-    fn auth_methods(&self) -> &[acp::AuthMethod] {
-        &[] // No auth for in-process
-    }
-
-    fn authenticate(&self, _method: acp::AuthMethodId, _cx: &mut App) -> Task<Result<()>> {
-        Task::ready(Ok(()))
-    }
-
-    fn model_selector(&self) -> Option<Rc<dyn ModelSelector>> {
-        Some(Rc::new(self.clone()) as Rc<dyn ModelSelector>)
-    }
-
-    fn prompt(
-        &self,
-        params: acp::PromptRequest,
        cx: &mut App,
+        f: impl 'static
+        + FnOnce(
+            Entity<Thread>,
+            &mut App,
+        ) -> Result<mpsc::UnboundedReceiver<Result<AgentResponseEvent>>>,
    ) -> Task<Result<acp::PromptResponse>> {
-        let session_id = params.session_id.clone();
-        let agent = self.0.clone();
-        log::info!("Received prompt request for session: {}", session_id);
-        log::debug!("Prompt blocks count: {}", params.prompt.len());
+        let Some((thread, acp_thread)) = self.0.update(cx, |agent, _cx| {
+            agent
+                .sessions
+                .get_mut(&session_id)
+                .map(|s| (s.thread.clone(), s.acp_thread.clone()))
+        }) else {
+            return Task::ready(Err(anyhow!("Session not found")));
+        };
+        log::debug!("Found session for: {}", session_id);

+        let mut response_stream = match f(thread, cx) {
+            Ok(stream) => stream,
+            Err(err) => return Task::ready(Err(err)),
+        };
        cx.spawn(async move |cx| {
-            // Get session
-            let (thread, acp_thread) = agent
-                .update(cx, |agent, _| {
-                    agent
-                        .sessions
-                        .get_mut(&session_id)
-                        .map(|s| (s.thread.clone(), s.acp_thread.clone()))
-                })?
-                .ok_or_else(|| {
-                    log::error!("Session not found: {}", session_id);
-                    anyhow::anyhow!("Session not found")
-                })?;
-            log::debug!("Found session for: {}", session_id);
-
-            let message: Vec<MessageContent> = params
-                .prompt
-                .into_iter()
-                .map(Into::into)
-                .collect::<Vec<_>>();
-            log::info!("Converted prompt to message: {} chars", message.len());
-            log::debug!("Message content: {:?}", message);
-
-            // Get model using the ModelSelector capability (always available for agent2)
-            // Get the selected model from the thread directly
-            let model = thread.read_with(cx, |thread, _| thread.selected_model.clone())?;
-
-            // Send to thread
-            log::info!("Sending message to thread with model: {:?}", model.name());
-            let mut response_stream = thread.update(cx, |thread, cx| thread.send(message, cx))?;
-
            // Handle response stream and forward to session.acp_thread
            while let Some(result) = response_stream.next().await {
                match result {
@@ -572,10 +514,11 @@ impl acp_thread::AgentConnection for NativeAgentConnection {
                                    thread.request_tool_call_authorization(tool_call, options, cx)
                                })?;
                                cx.background_spawn(async move {
-                                    if let Some(option) = recv
-                                        .await
-                                        .context("authorization sender was dropped")
-                                        .log_err()
+                                    if let Some(recv) = recv.log_err()
+                                        && let Some(option) = recv
+                                            .await
+                                            .context("authorization sender was dropped")
+                                            .log_err()
                                    {
                                        response
                                            .send(option)
@@ -588,7 +531,7 @@ impl acp_thread::AgentConnection for NativeAgentConnection {
                            AgentResponseEvent::ToolCall(tool_call) => {
                                acp_thread.update(cx, |thread, cx| {
                                    thread.upsert_tool_call(tool_call, cx)
-                                })?;
+                                })??;
                            }
                            AgentResponseEvent::ToolCallUpdate(update) => {
                                acp_thread.update(cx, |thread, cx| {
@@ -603,8 +546,7 @@ impl acp_thread::AgentConnection for NativeAgentConnection {
                    }
                    Err(e) => {
                        log::error!("Error in model response stream: {:?}", e);
-                        // TODO: Consider sending an error message to the UI
-                        break;
+                        return Err(e);
                    }
                }
            }
@@ -615,6 +557,246 @@ impl acp_thread::AgentConnection for NativeAgentConnection {
            })
        })
    }
+}
+
+impl AgentModelSelector for NativeAgentConnection {
+    fn list_models(&self, cx: &mut App) -> Task<Result<acp_thread::AgentModelList>> {
+        log::debug!("NativeAgentConnection::list_models called");
+        let list = self.0.read(cx).models.model_list.clone();
+        Task::ready(if list.is_empty() {
+            Err(anyhow::anyhow!("No models available"))
+        } else {
+            Ok(list)
+        })
+    }
+
+    fn select_model(
+        &self,
+        session_id: acp::SessionId,
+        model_id: acp_thread::AgentModelId,
+        cx: &mut App,
+    ) -> Task<Result<()>> {
+        log::info!("Setting model for session {}: {}", session_id, model_id);
+        let Some(thread) = self
+            .0
+            .read(cx)
+            .sessions
+            .get(&session_id)
+            .map(|session| session.thread.clone())
+        else {
+            return Task::ready(Err(anyhow!("Session not found")));
+        };
+
+        let Some(model) = self.0.read(cx).models.model_from_id(&model_id) else {
+            return Task::ready(Err(anyhow!("Invalid model ID {}", model_id)));
+        };
+
+        thread.update(cx, |thread, _cx| {
+            thread.set_model(model.clone());
+        });
+
+        update_settings_file::<AgentSettings>(
+            self.0.read(cx).fs.clone(),
+            cx,
+            move |settings, _cx| {
+                settings.set_model(model);
+            },
+        );
+
+        Task::ready(Ok(()))
+    }
+
+    fn selected_model(
+        &self,
+        session_id: &acp::SessionId,
+        cx: &mut App,
+    ) -> Task<Result<acp_thread::AgentModelInfo>> {
+        let session_id = session_id.clone();
+
+        let Some(thread) = self
+            .0
+            .read(cx)
+            .sessions
+            .get(&session_id)
+            .map(|session| session.thread.clone())
+        else {
+            return Task::ready(Err(anyhow!("Session not found")));
+        };
+        let model = thread.read(cx).model().clone();
+        let Some(provider) = LanguageModelRegistry::read_global(cx).provider(&model.provider_id())
+        else {
+            return Task::ready(Err(anyhow!("Provider not found")));
+        };
+        Task::ready(Ok(LanguageModels::map_language_model_to_info(
+            &model, &provider,
+        )))
+    }
+
+    fn watch(&self, cx: &mut App) -> watch::Receiver<()> {
+        self.0.read(cx).models.watch()
+    }
+}
+
+impl acp_thread::AgentConnection for NativeAgentConnection {
+    fn new_thread(
+        self: Rc<Self>,
+        project: Entity<Project>,
+        cwd: &Path,
+        cx: &mut App,
+    ) -> Task<Result<Entity<acp_thread::AcpThread>>> {
+        let agent = self.0.clone();
+        log::info!("Creating new thread for project at: {:?}", cwd);
+
+        cx.spawn(async move |cx| {
+            log::debug!("Starting thread creation in async context");
+
+            // Generate session ID
+            let session_id = acp::SessionId(uuid::Uuid::new_v4().to_string().into());
+            log::info!("Created session with ID: {}", session_id);
+
+            // Create AcpThread
+            let acp_thread = cx.update(|cx| {
+                cx.new(|cx| {
+                    acp_thread::AcpThread::new(
+                        "agent2",
+                        self.clone(),
+                        project.clone(),
+                        session_id.clone(),
+                        cx,
+                    )
+                })
+            })?;
+            let action_log = cx.update(|cx| acp_thread.read(cx).action_log().clone())?;
+
+            // Create Thread
+            let thread = agent.update(
+                cx,
+                |agent, cx: &mut gpui::Context<NativeAgent>| -> Result<_> {
+                    // Fetch default model from registry settings
+                    let registry = LanguageModelRegistry::read_global(cx);
+
+                    // Log available models for debugging
+                    let available_count = registry.available_models(cx).count();
+                    log::debug!("Total available models: {}", available_count);
+
+                    let default_model = registry
+                        .default_model()
+                        .and_then(|default_model| {
+                            agent
+                                .models
+                                .model_from_id(&LanguageModels::model_id(&default_model.model))
+                        })
+                        .ok_or_else(|| {
+                            log::warn!("No default model configured in settings");
+                            anyhow!(
+                                "No default model. Please configure a default model in settings."
+                            )
+                        })?;
+
+                    let thread = cx.new(|cx| {
+                        let mut thread = Thread::new(
+                            project.clone(),
+                            agent.project_context.clone(),
+                            agent.context_server_registry.clone(),
+                            action_log.clone(),
+                            agent.templates.clone(),
+                            default_model,
+                            cx,
+                        );
+                        thread.add_tool(CopyPathTool::new(project.clone()));
+                        thread.add_tool(CreateDirectoryTool::new(project.clone()));
+                        thread.add_tool(DeletePathTool::new(project.clone(), action_log.clone()));
+                        thread.add_tool(DiagnosticsTool::new(project.clone()));
+                        thread.add_tool(EditFileTool::new(cx.entity()));
+                        thread.add_tool(FetchTool::new(project.read(cx).client().http_client()));
+                        thread.add_tool(FindPathTool::new(project.clone()));
+                        thread.add_tool(GrepTool::new(project.clone()));
+                        thread.add_tool(ListDirectoryTool::new(project.clone()));
+                        thread.add_tool(MovePathTool::new(project.clone()));
+                        thread.add_tool(NowTool);
+                        thread.add_tool(OpenTool::new(project.clone()));
+                        thread.add_tool(ReadFileTool::new(project.clone(), action_log));
+                        thread.add_tool(TerminalTool::new(project.clone(), cx));
+                        thread.add_tool(ThinkingTool);
+                        thread.add_tool(WebSearchTool); // TODO: Enable this only if it's a zed model.
+                        thread
+                    });
+
+                    Ok(thread)
+                },
+            )??;
+
+            // Store the session
+            agent.update(cx, |agent, cx| {
+                agent.sessions.insert(
+                    session_id,
+                    Session {
+                        thread,
+                        acp_thread: acp_thread.downgrade(),
+                        _subscription: cx.observe_release(&acp_thread, |this, acp_thread, _cx| {
+                            this.sessions.remove(acp_thread.session_id());
+                        }),
+                    },
+                );
+            })?;
+
+            Ok(acp_thread)
+        })
+    }
+
+    fn auth_methods(&self) -> &[acp::AuthMethod] {
+        &[] // No auth for in-process
+    }
+
+    fn authenticate(&self, _method: acp::AuthMethodId, _cx: &mut App) -> Task<Result<()>> {
+        Task::ready(Ok(()))
+    }
+
+    fn model_selector(&self) -> Option<Rc<dyn AgentModelSelector>> {
+        Some(Rc::new(self.clone()) as Rc<dyn AgentModelSelector>)
+    }
+
+    fn prompt(
+        &self,
+        id: Option<acp_thread::UserMessageId>,
+        params: acp::PromptRequest,
+        cx: &mut App,
+    ) -> Task<Result<acp::PromptResponse>> {
+        let id = id.expect("UserMessageId is required");
+        let session_id = params.session_id.clone();
+        log::info!("Received prompt request for session: {}", session_id);
+        log::debug!("Prompt blocks count: {}", params.prompt.len());
+
+        self.run_turn(session_id, cx, |thread, cx| {
+            let content: Vec<UserMessageContent> = params
+                .prompt
+                .into_iter()
+                .map(Into::into)
+                .collect::<Vec<_>>();
+            log::info!("Converted prompt to message: {} chars", content.len());
+            log::debug!("Message id: {:?}", id);
+            log::debug!("Message content: {:?}", content);
+
+            Ok(thread.update(cx, |thread, cx| {
+                log::info!(
+                    "Sending message to thread with model: {:?}",
+                    thread.model().name()
+                );
+                thread.send(id, content, cx)
+            }))
+        })
+    }
+
+    fn resume(
+        &self,
+        session_id: &acp::SessionId,
+        _cx: &mut App,
+    ) -> Option<Rc<dyn acp_thread::AgentSessionResume>> {
+        Some(Rc::new(NativeAgentSessionResume {
+            connection: self.clone(),
+            session_id: session_id.clone(),
+        }) as _)
+    }

    fn cancel(&self, session_id: &acp::SessionId, cx: &mut App) {
        log::info!("Cancelling on session: {}", session_id);
@@ -624,11 +806,51 @@ impl acp_thread::AgentConnection for NativeAgentConnection {
            }
        });
    }
+
+    fn session_editor(
+        &self,
+        session_id: &agent_client_protocol::SessionId,
+        cx: &mut App,
+    ) -> Option<Rc<dyn acp_thread::AgentSessionEditor>> {
+        self.0.update(cx, |agent, _cx| {
+            agent
+                .sessions
+                .get(session_id)
+                .map(|session| Rc::new(NativeAgentSessionEditor(session.thread.clone())) as _)
+        })
+    }
+
+    fn into_any(self: Rc<Self>) -> Rc<dyn Any> {
+        self
+    }
+}
+
+struct NativeAgentSessionEditor(Entity<Thread>);
+
+impl acp_thread::AgentSessionEditor for NativeAgentSessionEditor {
+    fn truncate(&self, message_id: acp_thread::UserMessageId, cx: &mut App) -> Task<Result<()>> {
+        Task::ready(self.0.update(cx, |thread, _cx| thread.truncate(message_id)))
+    }
+}
+
+struct NativeAgentSessionResume {
+    connection: NativeAgentConnection,
+    session_id: acp::SessionId,
+}
+
+impl acp_thread::AgentSessionResume for NativeAgentSessionResume {
+    fn run(&self, cx: &mut App) -> Task<Result<acp::PromptResponse>> {
+        self.connection
+            .run_turn(self.session_id.clone(), cx, |thread, cx| {
+                thread.update(cx, |thread, cx| thread.resume(cx))
+            })
+    }
 }

 #[cfg(test)]
 mod tests {
    use super::*;
+    use acp_thread::{AgentConnection, AgentModelGroupName, AgentModelId, AgentModelInfo};
    use fs::FakeFs;
    use gpui::TestAppContext;
    use serde_json::json;
@@ -646,9 +868,15 @@ mod tests {
        )
        .await;
        let project = Project::test(fs.clone(), [], cx).await;
-        let agent = NativeAgent::new(project.clone(), Templates::new(), None, &mut cx.to_async())
-            .await
-            .unwrap();
+        let agent = NativeAgent::new(
+            project.clone(),
+            Templates::new(),
+            None,
+            fs.clone(),
+            &mut cx.to_async(),
+        )
+        .await
+        .unwrap();
        agent.read_with(cx, |agent, _| {
            assert_eq!(agent.project_context.borrow().worktrees, vec![])
        });
@@ -689,13 +917,127 @@ mod tests {
        });
    }

+    #[gpui::test]
+    async fn test_listing_models(cx: &mut TestAppContext) {
+        init_test(cx);
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree("/", json!({ "a": {}  })).await;
+        let project = Project::test(fs.clone(), [], cx).await;
+        let connection = NativeAgentConnection(
+            NativeAgent::new(
+                project.clone(),
+                Templates::new(),
+                None,
+                fs.clone(),
+                &mut cx.to_async(),
+            )
+            .await
+            .unwrap(),
+        );
+
+        let models = cx.update(|cx| connection.list_models(cx)).await.unwrap();
+
+        let acp_thread::AgentModelList::Grouped(models) = models else {
+            panic!("Unexpected model group");
+        };
+        assert_eq!(
+            models,
+            IndexMap::from_iter([(
+                AgentModelGroupName("Fake".into()),
+                vec![AgentModelInfo {
+                    id: AgentModelId("fake/fake".into()),
+                    name: "Fake".into(),
+                    icon: Some(ui::IconName::ZedAssistant),
+                }]
+            )])
+        );
+    }
+
+    #[gpui::test]
+    async fn test_model_selection_persists_to_settings(cx: &mut TestAppContext) {
+        init_test(cx);
+        let fs = FakeFs::new(cx.executor());
+        fs.create_dir(paths::settings_file().parent().unwrap())
+            .await
+            .unwrap();
+        fs.insert_file(
+            paths::settings_file(),
+            json!({
+                "agent": {
+                    "default_model": {
+                        "provider": "foo",
+                        "model": "bar"
+                    }
+                }
+            })
+            .to_string()
+            .into_bytes(),
+        )
+        .await;
+        let project = Project::test(fs.clone(), [], cx).await;
+
+        // Create the agent and connection
+        let agent = NativeAgent::new(
+            project.clone(),
+            Templates::new(),
+            None,
+            fs.clone(),
+            &mut cx.to_async(),
+        )
+        .await
+        .unwrap();
+        let connection = NativeAgentConnection(agent.clone());
+
+        // Create a thread/session
+        let acp_thread = cx
+            .update(|cx| {
+                Rc::new(connection.clone()).new_thread(project.clone(), Path::new("/a"), cx)
+            })
+            .await
+            .unwrap();
+
+        let session_id = cx.update(|cx| acp_thread.read(cx).session_id().clone());
+
+        // Select a model
+        let model_id = AgentModelId("fake/fake".into());
+        cx.update(|cx| connection.select_model(session_id.clone(), model_id.clone(), cx))
+            .await
+            .unwrap();
+
+        // Verify the thread has the selected model
+        agent.read_with(cx, |agent, _| {
+            let session = agent.sessions.get(&session_id).unwrap();
+            session.thread.read_with(cx, |thread, _| {
+                assert_eq!(thread.model().id().0, "fake");
+            });
+        });
+
+        cx.run_until_parked();
+
+        // Verify settings file was updated
+        let settings_content = fs.load(paths::settings_file()).await.unwrap();
+        let settings_json: serde_json::Value = serde_json::from_str(&settings_content).unwrap();
+
+        // Check that the agent settings contain the selected model
+        assert_eq!(
+            settings_json["agent"]["default_model"]["model"],
+            json!("fake")
+        );
+        assert_eq!(
+            settings_json["agent"]["default_model"]["provider"],
+            json!("fake")
+        );
+    }
+
    fn init_test(cx: &mut TestAppContext) {
        env_logger::try_init().ok();
        cx.update(|cx| {
            let settings_store = SettingsStore::test(cx);
            cx.set_global(settings_store);
            Project::init_settings(cx);
+            agent_settings::init(cx);
            language::init(cx);
+            LanguageModelRegistry::test(cx);
        });
    }
 }
--- a/crates/agent2/src/native_agent_server.rs
+++ b/crates/agent2/src/native_agent_server.rs
@@ -1,8 +1,8 @@
-use std::path::Path;
-use std::rc::Rc;
+use std::{path::Path, rc::Rc, sync::Arc};

 use agent_servers::AgentServer;
 use anyhow::Result;
+use fs::Fs;
 use gpui::{App, Entity, Task};
 use project::Project;
 use prompt_store::PromptStore;
@@ -10,7 +10,15 @@ use prompt_store::PromptStore;
 use crate::{NativeAgent, NativeAgentConnection, templates::Templates};

 #[derive(Clone)]
-pub struct NativeAgentServer;
+pub struct NativeAgentServer {
+    fs: Arc<dyn Fs>,
+}
+
+impl NativeAgentServer {
+    pub fn new(fs: Arc<dyn Fs>) -> Self {
+        Self { fs }
+    }
+}

 impl AgentServer for NativeAgentServer {
    fn name(&self) -> &'static str {
@@ -41,6 +49,7 @@ impl AgentServer for NativeAgentServer {
            _root_dir
        );
        let project = project.clone();
+        let fs = self.fs.clone();
        let prompt_store = PromptStore::global(cx);
        cx.spawn(async move |cx| {
            log::debug!("Creating templates for native agent");
@@ -48,7 +57,7 @@ impl AgentServer for NativeAgentServer {
            let prompt_store = prompt_store.await?;

            log::debug!("Creating native agent entity");
-            let agent = NativeAgent::new(project, templates, Some(prompt_store), cx).await?;
+            let agent = NativeAgent::new(project, templates, Some(prompt_store), fs, cx).await?;

            // Create the connection wrapper
            let connection = NativeAgentConnection(agent);
--- a/crates/agent2/src/tests/mod.rs
+++ b/crates/agent2/src/tests/mod.rs
@@ -1,6 +1,5 @@
 use super::*;
-use crate::MessageContent;
-use acp_thread::AgentConnection;
+use acp_thread::{AgentConnection, AgentModelGroupName, AgentModelList, UserMessageId};
 use action_log::ActionLog;
 use agent_client_protocol::{self as acp};
 use agent_settings::AgentProfileId;
@@ -13,10 +12,11 @@ use gpui::{
 };
 use indoc::indoc;
 use language_model::{
-    LanguageModel, LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelId,
-    LanguageModelRegistry, LanguageModelToolResult, LanguageModelToolUse, Role, StopReason,
-    fake_provider::FakeLanguageModel,
+    LanguageModel, LanguageModelCompletionEvent, LanguageModelId, LanguageModelRegistry,
+    LanguageModelRequestMessage, LanguageModelToolResult, LanguageModelToolUse, MessageContent,
+    Role, StopReason, fake_provider::FakeLanguageModel,
 };
+use pretty_assertions::assert_eq;
 use project::Project;
 use prompt_store::ProjectContext;
 use reqwest_client::ReqwestClient;
@@ -38,15 +38,19 @@ async fn test_echo(cx: &mut TestAppContext) {

    let events = thread
        .update(cx, |thread, cx| {
-            thread.send("Testing: Reply with 'Hello'", cx)
+            thread.send(UserMessageId::new(), ["Testing: Reply with 'Hello'"], cx)
        })
        .collect()
        .await;
    thread.update(cx, |thread, _cx| {
        assert_eq!(
-            thread.messages().last().unwrap().content,
-            vec![MessageContent::Text("Hello".to_string())]
-        );
+            thread.last_message().unwrap().to_markdown(),
+            indoc! {"
+                ## Assistant
+
+                Hello
+            "}
+        )
    });
    assert_eq!(stop_events(events), vec![acp::StopReason::EndTurn]);
 }
@@ -59,12 +63,13 @@ async fn test_thinking(cx: &mut TestAppContext) {
    let events = thread
        .update(cx, |thread, cx| {
            thread.send(
-                indoc! {"
+                UserMessageId::new(),
+                [indoc! {"
                    Testing:

                    Generate a thinking step where you just think the word 'Think',
                    and have your final answer be 'Hello'
-                "},
+                "}],
                cx,
            )
        })
@@ -72,9 +77,10 @@ async fn test_thinking(cx: &mut TestAppContext) {
        .await;
    thread.update(cx, |thread, _cx| {
        assert_eq!(
-            thread.messages().last().unwrap().to_markdown(),
+            thread.last_message().unwrap().to_markdown(),
            indoc! {"
-                ## assistant
+                ## Assistant
+
                <think>Think</think>
                Hello
            "}
@@ -95,7 +101,9 @@ async fn test_system_prompt(cx: &mut TestAppContext) {

    project_context.borrow_mut().shell = "test-shell".into();
    thread.update(cx, |thread, _| thread.add_tool(EchoTool));
-    thread.update(cx, |thread, cx| thread.send("abc", cx));
+    thread.update(cx, |thread, cx| {
+        thread.send(UserMessageId::new(), ["abc"], cx)
+    });
    cx.run_until_parked();
    let mut pending_completions = fake_model.pending_completions();
    assert_eq!(
@@ -122,6 +130,134 @@ async fn test_system_prompt(cx: &mut TestAppContext) {
    );
 }

+#[gpui::test]
+async fn test_prompt_caching(cx: &mut TestAppContext) {
+    let ThreadTest { model, thread, .. } = setup(cx, TestModel::Fake).await;
+    let fake_model = model.as_fake();
+
+    // Send initial user message and verify it's cached
+    thread.update(cx, |thread, cx| {
+        thread.send(UserMessageId::new(), ["Message 1"], cx)
+    });
+    cx.run_until_parked();
+
+    let completion = fake_model.pending_completions().pop().unwrap();
+    assert_eq!(
+        completion.messages[1..],
+        vec![LanguageModelRequestMessage {
+            role: Role::User,
+            content: vec!["Message 1".into()],
+            cache: true
+        }]
+    );
+    fake_model.send_last_completion_stream_event(LanguageModelCompletionEvent::Text(
+        "Response to Message 1".into(),
+    ));
+    fake_model.end_last_completion_stream();
+    cx.run_until_parked();
+
+    // Send another user message and verify only the latest is cached
+    thread.update(cx, |thread, cx| {
+        thread.send(UserMessageId::new(), ["Message 2"], cx)
+    });
+    cx.run_until_parked();
+
+    let completion = fake_model.pending_completions().pop().unwrap();
+    assert_eq!(
+        completion.messages[1..],
+        vec![
+            LanguageModelRequestMessage {
+                role: Role::User,
+                content: vec!["Message 1".into()],
+                cache: false
+            },
+            LanguageModelRequestMessage {
+                role: Role::Assistant,
+                content: vec!["Response to Message 1".into()],
+                cache: false
+            },
+            LanguageModelRequestMessage {
+                role: Role::User,
+                content: vec!["Message 2".into()],
+                cache: true
+            }
+        ]
+    );
+    fake_model.send_last_completion_stream_event(LanguageModelCompletionEvent::Text(
+        "Response to Message 2".into(),
+    ));
+    fake_model.end_last_completion_stream();
+    cx.run_until_parked();
+
+    // Simulate a tool call and verify that the latest tool result is cached
+    thread.update(cx, |thread, _| thread.add_tool(EchoTool));
+    thread.update(cx, |thread, cx| {
+        thread.send(UserMessageId::new(), ["Use the echo tool"], cx)
+    });
+    cx.run_until_parked();
+
+    let tool_use = LanguageModelToolUse {
+        id: "tool_1".into(),
+        name: EchoTool.name().into(),
+        raw_input: json!({"text": "test"}).to_string(),
+        input: json!({"text": "test"}),
+        is_input_complete: true,
+    };
+    fake_model
+        .send_last_completion_stream_event(LanguageModelCompletionEvent::ToolUse(tool_use.clone()));
+    fake_model.end_last_completion_stream();
+    cx.run_until_parked();
+
+    let completion = fake_model.pending_completions().pop().unwrap();
+    let tool_result = LanguageModelToolResult {
+        tool_use_id: "tool_1".into(),
+        tool_name: EchoTool.name().into(),
+        is_error: false,
+        content: "test".into(),
+        output: Some("test".into()),
+    };
+    assert_eq!(
+        completion.messages[1..],
+        vec![
+            LanguageModelRequestMessage {
+                role: Role::User,
+                content: vec!["Message 1".into()],
+                cache: false
+            },
+            LanguageModelRequestMessage {
+                role: Role::Assistant,
+                content: vec!["Response to Message 1".into()],
+                cache: false
+            },
+            LanguageModelRequestMessage {
+                role: Role::User,
+                content: vec!["Message 2".into()],
+                cache: false
+            },
+            LanguageModelRequestMessage {
+                role: Role::Assistant,
+                content: vec!["Response to Message 2".into()],
+                cache: false
+            },
+            LanguageModelRequestMessage {
+                role: Role::User,
+                content: vec!["Use the echo tool".into()],
+                cache: false
+            },
+            LanguageModelRequestMessage {
+                role: Role::Assistant,
+                content: vec![MessageContent::ToolUse(tool_use)],
+                cache: false
+            },
+            LanguageModelRequestMessage {
+                role: Role::User,
+                content: vec![MessageContent::ToolResult(tool_result)],
+                cache: true
+            }
+        ]
+    );
+}
+
 #[gpui::test]
 #[ignore = "can't run on CI yet"]
 async fn test_basic_tool_calls(cx: &mut TestAppContext) {
@@ -132,7 +268,8 @@ async fn test_basic_tool_calls(cx: &mut TestAppContext) {
        .update(cx, |thread, cx| {
            thread.add_tool(EchoTool);
            thread.send(
-                "Now test the echo tool with 'Hello'. Does it work? Say 'Yes' or 'No'.",
+                UserMessageId::new(),
+                ["Now test the echo tool with 'Hello'. Does it work? Say 'Yes' or 'No'."],
                cx,
            )
        })
@@ -146,7 +283,11 @@ async fn test_basic_tool_calls(cx: &mut TestAppContext) {
            thread.remove_tool(&AgentTool::name(&EchoTool));
            thread.add_tool(DelayTool);
            thread.send(
-                "Now call the delay tool with 200ms. When the timer goes off, then you echo the output of the tool.",
+                UserMessageId::new(),
+                [
+                    "Now call the delay tool with 200ms.",
+                    "When the timer goes off, then you echo the output of the tool.",
+                ],
                cx,
            )
        })
@@ -156,13 +297,14 @@ async fn test_basic_tool_calls(cx: &mut TestAppContext) {
    thread.update(cx, |thread, _cx| {
        assert!(
            thread
-                .messages()
-                .last()
+                .last_message()
+                .unwrap()
+                .as_agent_message()
                .unwrap()
                .content
                .iter()
                .any(|content| {
-                    if let MessageContent::Text(text) = content {
+                    if let AgentMessageContent::Text(text) = content {
                        text.contains("Ding")
                    } else {
                        false
@@ -182,7 +324,7 @@ async fn test_streaming_tool_calls(cx: &mut TestAppContext) {
    // Test a tool call that's likely to complete *before* streaming stops.
    let mut events = thread.update(cx, |thread, cx| {
        thread.add_tool(WordListTool);
-        thread.send("Test the word_list tool.", cx)
+        thread.send(UserMessageId::new(), ["Test the word_list tool."], cx)
    });

    let mut saw_partial_tool_use = false;
@@ -190,8 +332,10 @@ async fn test_streaming_tool_calls(cx: &mut TestAppContext) {
        if let Ok(AgentResponseEvent::ToolCall(tool_call)) = event {
            thread.update(cx, |thread, _cx| {
                // Look for a tool use in the thread's last message
-                let last_content = thread.messages().last().unwrap().content.last().unwrap();
-                if let MessageContent::ToolUse(last_tool_use) = last_content {
+                let message = thread.last_message().unwrap();
+                let agent_message = message.as_agent_message().unwrap();
+                let last_content = agent_message.content.last().unwrap();
+                if let AgentMessageContent::ToolUse(last_tool_use) = last_content {
                    assert_eq!(last_tool_use.name.as_ref(), "word_list");
                    if tool_call.status == acp::ToolCallStatus::Pending {
                        if !last_tool_use.is_input_complete
@@ -229,7 +373,7 @@ async fn test_tool_authorization(cx: &mut TestAppContext) {

    let mut events = thread.update(cx, |thread, cx| {
        thread.add_tool(ToolRequiringPermission);
-        thread.send("abc", cx)
+        thread.send(UserMessageId::new(), ["abc"], cx)
    });
    cx.run_until_parked();
    fake_model.send_last_completion_stream_event(LanguageModelCompletionEvent::ToolUse(
@@ -357,7 +501,9 @@ async fn test_tool_hallucination(cx: &mut TestAppContext) {
    let ThreadTest { model, thread, .. } = setup(cx, TestModel::Fake).await;
    let fake_model = model.as_fake();

-    let mut events = thread.update(cx, |thread, cx| thread.send("abc", cx));
+    let mut events = thread.update(cx, |thread, cx| {
+        thread.send(UserMessageId::new(), ["abc"], cx)
+    });
    cx.run_until_parked();
    fake_model.send_last_completion_stream_event(LanguageModelCompletionEvent::ToolUse(
        LanguageModelToolUse {
@@ -377,8 +523,194 @@ async fn test_tool_hallucination(cx: &mut TestAppContext) {
    assert_eq!(update.fields.status, Some(acp::ToolCallStatus::Failed));
 }

+#[gpui::test]
+async fn test_resume_after_tool_use_limit(cx: &mut TestAppContext) {
+    let ThreadTest { model, thread, .. } = setup(cx, TestModel::Fake).await;
+    let fake_model = model.as_fake();
+
+    let events = thread.update(cx, |thread, cx| {
+        thread.add_tool(EchoTool);
+        thread.send(UserMessageId::new(), ["abc"], cx)
+    });
+    cx.run_until_parked();
+    let tool_use = LanguageModelToolUse {
+        id: "tool_id_1".into(),
+        name: EchoTool.name().into(),
+        raw_input: "{}".into(),
+        input: serde_json::to_value(&EchoToolInput { text: "def".into() }).unwrap(),
+        is_input_complete: true,
+    };
+    fake_model
+        .send_last_completion_stream_event(LanguageModelCompletionEvent::ToolUse(tool_use.clone()));
+    fake_model.end_last_completion_stream();
+
+    cx.run_until_parked();
+    let completion = fake_model.pending_completions().pop().unwrap();
+    let tool_result = LanguageModelToolResult {
+        tool_use_id: "tool_id_1".into(),
+        tool_name: EchoTool.name().into(),
+        is_error: false,
+        content: "def".into(),
+        output: Some("def".into()),
+    };
+    assert_eq!(
+        completion.messages[1..],
+        vec![
+            LanguageModelRequestMessage {
+                role: Role::User,
+                content: vec!["abc".into()],
+                cache: false
+            },
+            LanguageModelRequestMessage {
+                role: Role::Assistant,
+                content: vec![MessageContent::ToolUse(tool_use.clone())],
+                cache: false
+            },
+            LanguageModelRequestMessage {
+                role: Role::User,
+                content: vec![MessageContent::ToolResult(tool_result.clone())],
+                cache: true
+            },
+        ]
+    );
+
+    // Simulate reaching tool use limit.
+    fake_model.send_last_completion_stream_event(LanguageModelCompletionEvent::StatusUpdate(
+        cloud_llm_client::CompletionRequestStatus::ToolUseLimitReached,
+    ));
+    fake_model.end_last_completion_stream();
+    let last_event = events.collect::<Vec<_>>().await.pop().unwrap();
+    assert!(
+        last_event
+            .unwrap_err()
+            .is::<language_model::ToolUseLimitReachedError>()
+    );
+
+    let events = thread.update(cx, |thread, cx| thread.resume(cx)).unwrap();
+    cx.run_until_parked();
+    let completion = fake_model.pending_completions().pop().unwrap();
+    assert_eq!(
+        completion.messages[1..],
+        vec![
+            LanguageModelRequestMessage {
+                role: Role::User,
+                content: vec!["abc".into()],
+                cache: false
+            },
+            LanguageModelRequestMessage {
+                role: Role::Assistant,
+                content: vec![MessageContent::ToolUse(tool_use)],
+                cache: false
+            },
+            LanguageModelRequestMessage {
+                role: Role::User,
+                content: vec![MessageContent::ToolResult(tool_result)],
+                cache: false
+            },
+            LanguageModelRequestMessage {
+                role: Role::User,
+                content: vec!["Continue where you left off".into()],
+                cache: true
+            }
+        ]
+    );
+
+    fake_model.send_last_completion_stream_event(LanguageModelCompletionEvent::Text("Done".into()));
+    fake_model.end_last_completion_stream();
+    events.collect::<Vec<_>>().await;
+    thread.read_with(cx, |thread, _cx| {
+        assert_eq!(
+            thread.last_message().unwrap().to_markdown(),
+            indoc! {"
+                ## Assistant
+
+                Done
+            "}
+        )
+    });
+
+    // Ensure we error if calling resume when tool use limit was *not* reached.
+    let error = thread
+        .update(cx, |thread, cx| thread.resume(cx))
+        .unwrap_err();
+    assert_eq!(
+        error.to_string(),
+        "can only resume after tool use limit is reached"
+    )
+}
+
+#[gpui::test]
+async fn test_send_after_tool_use_limit(cx: &mut TestAppContext) {
+    let ThreadTest { model, thread, .. } = setup(cx, TestModel::Fake).await;
+    let fake_model = model.as_fake();
+
+    let events = thread.update(cx, |thread, cx| {
+        thread.add_tool(EchoTool);
+        thread.send(UserMessageId::new(), ["abc"], cx)
+    });
+    cx.run_until_parked();
+
+    let tool_use = LanguageModelToolUse {
+        id: "tool_id_1".into(),
+        name: EchoTool.name().into(),
+        raw_input: "{}".into(),
+        input: serde_json::to_value(&EchoToolInput { text: "def".into() }).unwrap(),
+        is_input_complete: true,
+    };
+    let tool_result = LanguageModelToolResult {
+        tool_use_id: "tool_id_1".into(),
+        tool_name: EchoTool.name().into(),
+        is_error: false,
+        content: "def".into(),
+        output: Some("def".into()),
+    };
+    fake_model
+        .send_last_completion_stream_event(LanguageModelCompletionEvent::ToolUse(tool_use.clone()));
+    fake_model.send_last_completion_stream_event(LanguageModelCompletionEvent::StatusUpdate(
+        cloud_llm_client::CompletionRequestStatus::ToolUseLimitReached,
+    ));
+    fake_model.end_last_completion_stream();
+    let last_event = events.collect::<Vec<_>>().await.pop().unwrap();
+    assert!(
+        last_event
+            .unwrap_err()
+            .is::<language_model::ToolUseLimitReachedError>()
+    );
+
+    thread.update(cx, |thread, cx| {
+        thread.send(UserMessageId::new(), vec!["ghi"], cx)
+    });
+    cx.run_until_parked();
+    let completion = fake_model.pending_completions().pop().unwrap();
+    assert_eq!(
+        completion.messages[1..],
+        vec![
+            LanguageModelRequestMessage {
+                role: Role::User,
+                content: vec!["abc".into()],
+                cache: false
+            },
+            LanguageModelRequestMessage {
+                role: Role::Assistant,
+                content: vec![MessageContent::ToolUse(tool_use)],
+                cache: false
+            },
+            LanguageModelRequestMessage {
+                role: Role::User,
+                content: vec![MessageContent::ToolResult(tool_result)],
+                cache: false
+            },
+            LanguageModelRequestMessage {
+                role: Role::User,
+                content: vec!["ghi".into()],
+                cache: true
+            }
+        ]
+    );
+}
+
 async fn expect_tool_call(
-    events: &mut UnboundedReceiver<Result<AgentResponseEvent, LanguageModelCompletionError>>,
+    events: &mut UnboundedReceiver<Result<AgentResponseEvent>>,
 ) -> acp::ToolCall {
    let event = events
        .next()
@@ -394,7 +726,7 @@ async fn expect_tool_call(
 }

 async fn expect_tool_call_update_fields(
-    events: &mut UnboundedReceiver<Result<AgentResponseEvent, LanguageModelCompletionError>>,
+    events: &mut UnboundedReceiver<Result<AgentResponseEvent>>,
 ) -> acp::ToolCallUpdate {
    let event = events
        .next()
@@ -412,7 +744,7 @@ async fn expect_tool_call_update_fields(
 }

 async fn next_tool_call_authorization(
-    events: &mut UnboundedReceiver<Result<AgentResponseEvent, LanguageModelCompletionError>>,
+    events: &mut UnboundedReceiver<Result<AgentResponseEvent>>,
 ) -> ToolCallAuthorization {
    loop {
        let event = events
@@ -449,7 +781,12 @@ async fn test_concurrent_tool_calls(cx: &mut TestAppContext) {
        .update(cx, |thread, cx| {
            thread.add_tool(DelayTool);
            thread.send(
-                "Call the delay tool twice in the same message. Once with 100ms. Once with 300ms. When both timers are complete, describe the outputs.",
+                UserMessageId::new(),
+                [
+                    "Call the delay tool twice in the same message.",
+                    "Once with 100ms. Once with 300ms.",
+                    "When both timers are complete, describe the outputs.",
+                ],
                cx,
            )
        })
@@ -460,12 +797,13 @@ async fn test_concurrent_tool_calls(cx: &mut TestAppContext) {
    assert_eq!(stop_reasons, vec![acp::StopReason::EndTurn]);

    thread.update(cx, |thread, _cx| {
-        let last_message = thread.messages().last().unwrap();
-        let text = last_message
+        let last_message = thread.last_message().unwrap();
+        let agent_message = last_message.as_agent_message().unwrap();
+        let text = agent_message
            .content
            .iter()
            .filter_map(|content| {
-                if let MessageContent::Text(text) = content {
+                if let AgentMessageContent::Text(text) = content {
                    Some(text.as_str())
                } else {
                    None
@@ -521,7 +859,7 @@ async fn test_profiles(cx: &mut TestAppContext) {
    // Test that test-1 profile (default) has echo and delay tools
    thread.update(cx, |thread, cx| {
        thread.set_profile(AgentProfileId("test-1".into()));
-        thread.send("test", cx);
+        thread.send(UserMessageId::new(), ["test"], cx);
    });
    cx.run_until_parked();

@@ -539,7 +877,7 @@ async fn test_profiles(cx: &mut TestAppContext) {
    // Switch to test-2 profile, and verify that it has only the infinite tool.
    thread.update(cx, |thread, cx| {
        thread.set_profile(AgentProfileId("test-2".into()));
-        thread.send("test2", cx)
+        thread.send(UserMessageId::new(), ["test2"], cx)
    });
    cx.run_until_parked();
    let mut pending_completions = fake_model.pending_completions();
@@ -562,7 +900,8 @@ async fn test_cancellation(cx: &mut TestAppContext) {
        thread.add_tool(InfiniteTool);
        thread.add_tool(EchoTool);
        thread.send(
-            "Call the echo tool and then call the infinite tool, then explain their output",
+            UserMessageId::new(),
+            ["Call the echo tool, then call the infinite tool, then explain their output"],
            cx,
        )
    });
@@ -607,14 +946,20 @@ async fn test_cancellation(cx: &mut TestAppContext) {
    // Ensure we can still send a new message after cancellation.
    let events = thread
        .update(cx, |thread, cx| {
-            thread.send("Testing: reply with 'Hello' then stop.", cx)
+            thread.send(
+                UserMessageId::new(),
+                ["Testing: reply with 'Hello' then stop."],
+                cx,
+            )
        })
        .collect::<Vec<_>>()
        .await;
    thread.update(cx, |thread, _cx| {
+        let message = thread.last_message().unwrap();
+        let agent_message = message.as_agent_message().unwrap();
        assert_eq!(
-            thread.messages().last().unwrap().content,
-            vec![MessageContent::Text("Hello".to_string())]
+            agent_message.content,
+            vec![AgentMessageContent::Text("Hello".to_string())]
        );
    });
    assert_eq!(stop_events(events), vec![acp::StopReason::EndTurn]);
@@ -625,13 +970,16 @@ async fn test_refusal(cx: &mut TestAppContext) {
    let ThreadTest { model, thread, .. } = setup(cx, TestModel::Fake).await;
    let fake_model = model.as_fake();

-    let events = thread.update(cx, |thread, cx| thread.send("Hello", cx));
+    let events = thread.update(cx, |thread, cx| {
+        thread.send(UserMessageId::new(), ["Hello"], cx)
+    });
    cx.run_until_parked();
    thread.read_with(cx, |thread, _| {
        assert_eq!(
            thread.to_markdown(),
            indoc! {"
-                ## user
+                ## User
+
                Hello
            "}
        );
@@ -643,9 +991,12 @@ async fn test_refusal(cx: &mut TestAppContext) {
        assert_eq!(
            thread.to_markdown(),
            indoc! {"
-                ## user
+                ## User
+
                Hello
-                ## assistant
+
+                ## Assistant
+
                Hey!
            "}
        );
@@ -661,6 +1012,85 @@ async fn test_refusal(cx: &mut TestAppContext) {
    });
 }

+#[gpui::test]
+async fn test_truncate(cx: &mut TestAppContext) {
+    let ThreadTest { model, thread, .. } = setup(cx, TestModel::Fake).await;
+    let fake_model = model.as_fake();
+
+    let message_id = UserMessageId::new();
+    thread.update(cx, |thread, cx| {
+        thread.send(message_id.clone(), ["Hello"], cx)
+    });
+    cx.run_until_parked();
+    thread.read_with(cx, |thread, _| {
+        assert_eq!(
+            thread.to_markdown(),
+            indoc! {"
+                ## User
+
+                Hello
+            "}
+        );
+    });
+
+    fake_model.send_last_completion_stream_text_chunk("Hey!");
+    cx.run_until_parked();
+    thread.read_with(cx, |thread, _| {
+        assert_eq!(
+            thread.to_markdown(),
+            indoc! {"
+                ## User
+
+                Hello
+
+                ## Assistant
+
+                Hey!
+            "}
+        );
+    });
+
+    thread
+        .update(cx, |thread, _cx| thread.truncate(message_id))
+        .unwrap();
+    cx.run_until_parked();
+    thread.read_with(cx, |thread, _| {
+        assert_eq!(thread.to_markdown(), "");
+    });
+
+    // Ensure we can still send a new message after truncation.
+    thread.update(cx, |thread, cx| {
+        thread.send(UserMessageId::new(), ["Hi"], cx)
+    });
+    thread.update(cx, |thread, _cx| {
+        assert_eq!(
+            thread.to_markdown(),
+            indoc! {"
+                ## User
+
+                Hi
+            "}
+        );
+    });
+    cx.run_until_parked();
+    fake_model.send_last_completion_stream_text_chunk("Ahoy!");
+    cx.run_until_parked();
+    thread.read_with(cx, |thread, _| {
+        assert_eq!(
+            thread.to_markdown(),
+            indoc! {"
+                ## User
+
+                Hi
+
+                ## Assistant
+
+                Ahoy!
+            "}
+        );
+    });
+}
+
 #[gpui::test]
 async fn test_agent_connection(cx: &mut TestAppContext) {
    cx.update(settings::init);
@@ -686,13 +1116,19 @@ async fn test_agent_connection(cx: &mut TestAppContext) {
    // Create a project for new_thread
    let fake_fs = cx.update(|cx| fs::FakeFs::new(cx.background_executor().clone()));
    fake_fs.insert_tree(path!("/test"), json!({})).await;
-    let project = Project::test(fake_fs, [Path::new("/test")], cx).await;
+    let project = Project::test(fake_fs.clone(), [Path::new("/test")], cx).await;
    let cwd = Path::new("/test");

    // Create agent and connection
-    let agent = NativeAgent::new(project.clone(), templates.clone(), None, &mut cx.to_async())
-        .await
-        .unwrap();
+    let agent = NativeAgent::new(
+        project.clone(),
+        templates.clone(),
+        None,
+        fake_fs.clone(),
+        &mut cx.to_async(),
+    )
+    .await
+    .unwrap();
    let connection = NativeAgentConnection(agent.clone());

    // Test model_selector returns Some
@@ -705,22 +1141,22 @@ async fn test_agent_connection(cx: &mut TestAppContext) {

    // Test list_models
    let listed_models = cx
-        .update(|cx| {
-            let mut async_cx = cx.to_async();
-            selector.list_models(&mut async_cx)
-        })
+        .update(|cx| selector.list_models(cx))
        .await
        .expect("list_models should succeed");
+    let AgentModelList::Grouped(listed_models) = listed_models else {
+        panic!("Unexpected model list type");
+    };
    assert!(!listed_models.is_empty(), "should have at least one model");
-    assert_eq!(listed_models[0].id().0, "fake");
+    assert_eq!(
+        listed_models[&AgentModelGroupName("Fake".into())][0].id.0,
+        "fake/fake"
+    );

    // Create a thread using new_thread
    let connection_rc = Rc::new(connection.clone());
    let acp_thread = cx
-        .update(|cx| {
-            let mut async_cx = cx.to_async();
-            connection_rc.new_thread(project, cwd, &mut async_cx)
-        })
+        .update(|cx| connection_rc.new_thread(project, cwd, cx))
        .await
        .expect("new_thread should succeed");

@@ -729,12 +1165,12 @@ async fn test_agent_connection(cx: &mut TestAppContext) {

    // Test selected_model returns the default
    let model = cx
-        .update(|cx| {
-            let mut async_cx = cx.to_async();
-            selector.selected_model(&session_id, &mut async_cx)
-        })
+        .update(|cx| selector.selected_model(&session_id, cx))
        .await
        .expect("selected_model should succeed");
+    let model = cx
+        .update(|cx| agent.read(cx).models().model_from_id(&model.id))
+        .unwrap();
    let model = model.as_fake();
    assert_eq!(model.id().0, "fake", "should return default model");

@@ -768,6 +1204,7 @@ async fn test_agent_connection(cx: &mut TestAppContext) {
    let result = cx
        .update(|cx| {
            connection.prompt(
+                Some(acp_thread::UserMessageId::new()),
                acp::PromptRequest {
                    session_id: session_id.clone(),
                    prompt: vec!["ghi".into()],
@@ -790,7 +1227,9 @@ async fn test_tool_updates_to_completion(cx: &mut TestAppContext) {
    thread.update(cx, |thread, _cx| thread.add_tool(ThinkingTool));
    let fake_model = model.as_fake();

-    let mut events = thread.update(cx, |thread, cx| thread.send("Think", cx));
+    let mut events = thread.update(cx, |thread, cx| {
+        thread.send(UserMessageId::new(), ["Think"], cx)
+    });
    cx.run_until_parked();

    // Simulate streaming partial input.
@@ -883,9 +1322,7 @@ async fn test_tool_updates_to_completion(cx: &mut TestAppContext) {
 }

 /// Filters out the stop events for asserting against in tests
-fn stop_events(
-    result_events: Vec<Result<AgentResponseEvent, LanguageModelCompletionError>>,
-) -> Vec<acp::StopReason> {
+fn stop_events(result_events: Vec<Result<AgentResponseEvent>>) -> Vec<acp::StopReason> {
    result_events
        .into_iter()
        .filter_map(|event| match event.unwrap() {
--- a/crates/agent2/src/tests/test_tools.rs
+++ b/crates/agent2/src/tests/test_tools.rs
@@ -7,7 +7,7 @@ use std::future;
 #[derive(JsonSchema, Serialize, Deserialize)]
 pub struct EchoToolInput {
    /// The text to echo.
-    text: String,
+    pub text: String,
 }

 pub struct EchoTool;
--- a/crates/agent2/src/thread.rs
+++ b/crates/agent2/src/thread.rs
--- a/crates/agent2/src/tools/edit_file_tool.rs
+++ b/crates/agent2/src/tools/edit_file_tool.rs
@@ -1,12 +1,13 @@
 use crate::{AgentTool, Thread, ToolCallEventStream};
 use acp_thread::Diff;
-use agent_client_protocol as acp;
+use agent_client_protocol::{self as acp, ToolCallLocation, ToolCallUpdateFields};
 use anyhow::{Context as _, Result, anyhow};
 use assistant_tools::edit_agent::{EditAgent, EditAgentOutput, EditAgentOutputEvent, EditFormat};
 use cloud_llm_client::CompletionIntent;
 use collections::HashSet;
 use gpui::{App, AppContext, AsyncApp, Entity, Task};
 use indoc::formatdoc;
+use language::ToPoint;
 use language::language_settings::{self, FormatOnSave};
 use language_model::LanguageModelToolResultContent;
 use paths;
@@ -225,12 +226,22 @@ impl AgentTool for EditFileTool {
            Ok(path) => path,
            Err(err) => return Task::ready(Err(anyhow!(err))),
        };
+        let abs_path = project.read(cx).absolute_path(&project_path, cx);
+        if let Some(abs_path) = abs_path.clone() {
+            event_stream.update_fields(ToolCallUpdateFields {
+                locations: Some(vec![acp::ToolCallLocation {
+                    path: abs_path,
+                    line: None,
+                }]),
+                ..Default::default()
+            });
+        }

        let request = self.thread.update(cx, |thread, cx| {
            thread.build_completion_request(CompletionIntent::ToolResults, cx)
        });
        let thread = self.thread.read(cx);
-        let model = thread.selected_model.clone();
+        let model = thread.model().clone();
        let action_log = thread.action_log().clone();

        let authorize = self.authorize(&input, &event_stream, cx);
@@ -283,13 +294,38 @@ impl AgentTool for EditFileTool {

            let mut hallucinated_old_text = false;
            let mut ambiguous_ranges = Vec::new();
+            let mut emitted_location = false;
            while let Some(event) = events.next().await {
                match event {
-                    EditAgentOutputEvent::Edited => {},
+                    EditAgentOutputEvent::Edited(range) => {
+                        if !emitted_location {
+                            let line = buffer.update(cx, |buffer, _cx| {
+                                range.start.to_point(&buffer.snapshot()).row
+                            }).ok();
+                            if let Some(abs_path) = abs_path.clone() {
+                                event_stream.update_fields(ToolCallUpdateFields {
+                                    locations: Some(vec![ToolCallLocation { path: abs_path, line }]),
+                                    ..Default::default()
+                                });
+                            }
+                            emitted_location = true;
+                        }
+                    },
                    EditAgentOutputEvent::UnresolvedEditRange => hallucinated_old_text = true,
                    EditAgentOutputEvent::AmbiguousEditRange(ranges) => ambiguous_ranges = ranges,
                    EditAgentOutputEvent::ResolvingEditRange(range) => {
-                        diff.update(cx, |card, cx| card.reveal_range(range, cx))?;
+                        diff.update(cx, |card, cx| card.reveal_range(range.clone(), cx))?;
+                        // if !emitted_location {
+                        //     let line = buffer.update(cx, |buffer, _cx| {
+                        //         range.start.to_point(&buffer.snapshot()).row
+                        //     }).ok();
+                        //     if let Some(abs_path) = abs_path.clone() {
+                        //         event_stream.update_fields(ToolCallUpdateFields {
+                        //             locations: Some(vec![ToolCallLocation { path: abs_path, line }]),
+                        //             ..Default::default()
+                        //         });
+                        //     }
+                        // }
                    }
                }
            }
@@ -965,7 +1001,10 @@ mod tests {
        });

        let event = stream_rx.expect_authorization().await;
-        assert_eq!(event.tool_call.title, "test 1 (local settings)");
+        assert_eq!(
+            event.tool_call.fields.title,
+            Some("test 1 (local settings)".into())
+        );

        // Test 2: Path outside project should require confirmation
        let (stream_tx, mut stream_rx) = ToolCallEventStream::test();
@@ -982,7 +1021,7 @@ mod tests {
        });

        let event = stream_rx.expect_authorization().await;
-        assert_eq!(event.tool_call.title, "test 2");
+        assert_eq!(event.tool_call.fields.title, Some("test 2".into()));

        // Test 3: Relative path without .zed should not require confirmation
        let (stream_tx, mut stream_rx) = ToolCallEventStream::test();
@@ -1015,7 +1054,10 @@ mod tests {
            )
        });
        let event = stream_rx.expect_authorization().await;
-        assert_eq!(event.tool_call.title, "test 4 (local settings)");
+        assert_eq!(
+            event.tool_call.fields.title,
+            Some("test 4 (local settings)".into())
+        );

        // Test 5: When always_allow_tool_actions is enabled, no confirmation needed
        cx.update(|cx| {
--- a/crates/agent2/src/tools/read_file_tool.rs
+++ b/crates/agent2/src/tools/read_file_tool.rs
@@ -1,10 +1,10 @@
 use action_log::ActionLog;
-use agent_client_protocol::{self as acp};
+use agent_client_protocol::{self as acp, ToolCallUpdateFields};
 use anyhow::{Context as _, Result, anyhow};
 use assistant_tool::outline;
 use gpui::{App, Entity, SharedString, Task};
 use indoc::formatdoc;
-use language::{Anchor, Point};
+use language::Point;
 use language_model::{LanguageModelImage, LanguageModelToolResultContent};
 use project::{AgentLocation, ImageItem, Project, WorktreeSettings, image_store};
 use schemars::JsonSchema;
@@ -97,7 +97,7 @@ impl AgentTool for ReadFileTool {
    fn run(
        self: Arc<Self>,
        input: Self::Input,
-        _event_stream: ToolCallEventStream,
+        event_stream: ToolCallEventStream,
        cx: &mut App,
    ) -> Task<Result<LanguageModelToolResultContent>> {
        let Some(project_path) = self.project.read(cx).find_project_path(&input.path, cx) else {
@@ -166,7 +166,9 @@ impl AgentTool for ReadFileTool {
        cx.spawn(async move |cx| {
            let buffer = cx
                .update(|cx| {
-                    project.update(cx, |project, cx| project.open_buffer(project_path, cx))
+                    project.update(cx, |project, cx| {
+                        project.open_buffer(project_path.clone(), cx)
+                    })
                })?
                .await?;
            if buffer.read_with(cx, |buffer, _| {
@@ -178,19 +180,10 @@ impl AgentTool for ReadFileTool {
                anyhow::bail!("{file_path} not found");
            }

-            project.update(cx, |project, cx| {
-                project.set_agent_location(
-                    Some(AgentLocation {
-                        buffer: buffer.downgrade(),
-                        position: Anchor::MIN,
-                    }),
-                    cx,
-                );
-            })?;
+            let mut anchor = None;

            // Check if specific line ranges are provided
-            if input.start_line.is_some() || input.end_line.is_some() {
-                let mut anchor = None;
+            let result = if input.start_line.is_some() || input.end_line.is_some() {
                let result = buffer.read_with(cx, |buffer, _cx| {
                    let text = buffer.text();
                    // .max(1) because despite instructions to be 1-indexed, sometimes the model passes 0.
@@ -214,18 +207,6 @@ impl AgentTool for ReadFileTool {
                    log.buffer_read(buffer.clone(), cx);
                })?;

-                if let Some(anchor) = anchor {
-                    project.update(cx, |project, cx| {
-                        project.set_agent_location(
-                            Some(AgentLocation {
-                                buffer: buffer.downgrade(),
-                                position: anchor,
-                            }),
-                            cx,
-                        );
-                    })?;
-                }
-
                Ok(result.into())
            } else {
                // No line ranges specified, so check file size to see if it's too big.
@@ -236,7 +217,7 @@ impl AgentTool for ReadFileTool {
                    let result = buffer.read_with(cx, |buffer, _cx| buffer.text())?;

                    action_log.update(cx, |log, cx| {
-                        log.buffer_read(buffer, cx);
+                        log.buffer_read(buffer.clone(), cx);
                    })?;

                    Ok(result.into())
@@ -244,7 +225,8 @@ impl AgentTool for ReadFileTool {
                    // File is too big, so return the outline
                    // and a suggestion to read again with line numbers.
                    let outline =
-                        outline::file_outline(project, file_path, action_log, None, cx).await?;
+                        outline::file_outline(project.clone(), file_path, action_log, None, cx)
+                            .await?;
                    Ok(formatdoc! {"
                        This file was too big to read all at once.

@@ -261,7 +243,28 @@ impl AgentTool for ReadFileTool {
                    }
                    .into())
                }
-            }
+            };
+
+            project.update(cx, |project, cx| {
+                if let Some(abs_path) = project.absolute_path(&project_path, cx) {
+                    project.set_agent_location(
+                        Some(AgentLocation {
+                            buffer: buffer.downgrade(),
+                            position: anchor.unwrap_or(text::Anchor::MIN),
+                        }),
+                        cx,
+                    );
+                    event_stream.update_fields(ToolCallUpdateFields {
+                        locations: Some(vec![acp::ToolCallLocation {
+                            path: abs_path,
+                            line: input.start_line.map(|line| line.saturating_sub(1)),
+                        }]),
+                        ..Default::default()
+                    });
+                }
+            })?;
+
+            result
        })
    }
 }
--- a/crates/agent2/src/tools/web_search_tool.rs
+++ b/crates/agent2/src/tools/web_search_tool.rs
@@ -5,7 +5,9 @@ use agent_client_protocol as acp;
 use anyhow::{Result, anyhow};
 use cloud_llm_client::WebSearchResponse;
 use gpui::{App, AppContext, Task};
-use language_model::LanguageModelToolResultContent;
+use language_model::{
+    LanguageModelProviderId, LanguageModelToolResultContent, ZED_CLOUD_PROVIDER_ID,
+};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use ui::prelude::*;
@@ -50,6 +52,11 @@ impl AgentTool for WebSearchTool {
        "Searching the Web".into()
    }

+    /// We currently only support Zed Cloud as a provider.
+    fn supported_provider(&self, provider: &LanguageModelProviderId) -> bool {
+        provider == &ZED_CLOUD_PROVIDER_ID
+    }
+
    fn run(
        self: Arc<Self>,
        input: Self::Input,
--- a/crates/agent_servers/src/acp/v0.rs
+++ b/crates/agent_servers/src/acp/v0.rs
@@ -5,7 +5,7 @@ use anyhow::{Context as _, Result, anyhow};
 use futures::channel::oneshot;
 use gpui::{AppContext as _, AsyncApp, Entity, Task, WeakEntity};
 use project::Project;
-use std::{cell::RefCell, path::Path, rc::Rc};
+use std::{any::Any, cell::RefCell, path::Path, rc::Rc};
 use ui::App;
 use util::ResultExt as _;

@@ -135,9 +135,9 @@ impl acp_old::Client for OldAcpClientDelegate {
        let response = cx
            .update(|cx| {
                self.thread.borrow().update(cx, |thread, cx| {
-                    thread.request_tool_call_authorization(tool_call, acp_options, cx)
+                    thread.request_tool_call_authorization(tool_call.into(), acp_options, cx)
                })
-            })?
+            })??
            .context("Failed to update thread")?
            .await;

@@ -168,7 +168,7 @@ impl acp_old::Client for OldAcpClientDelegate {
                    cx,
                )
            })
-        })?
+        })??
        .context("Failed to update thread")?;

        Ok(acp_old::PushToolCallResponse {
@@ -423,7 +423,7 @@ impl AgentConnection for AcpConnection {
        self: Rc<Self>,
        project: Entity<Project>,
        _cwd: &Path,
-        cx: &mut AsyncApp,
+        cx: &mut App,
    ) -> Task<Result<Entity<AcpThread>>> {
        let task = self.connection.request_any(
            acp_old::InitializeParams {
@@ -467,6 +467,7 @@ impl AgentConnection for AcpConnection {

    fn prompt(
        &self,
+        _id: Option<acp_thread::UserMessageId>,
        params: acp::PromptRequest,
        cx: &mut App,
    ) -> Task<Result<acp::PromptResponse>> {
@@ -506,4 +507,8 @@ impl AgentConnection for AcpConnection {
            })
            .detach_and_log_err(cx)
    }
+
+    fn into_any(self: Rc<Self>) -> Rc<dyn Any> {
+        self
+    }
 }
--- a/crates/agent_servers/src/acp/v1.rs
+++ b/crates/agent_servers/src/acp/v1.rs
@@ -1,11 +1,13 @@
 use agent_client_protocol::{self as acp, Agent as _};
 use anyhow::anyhow;
 use collections::HashMap;
+use futures::AsyncBufReadExt as _;
 use futures::channel::oneshot;
+use futures::io::BufReader;
 use project::Project;
-use std::cell::RefCell;
 use std::path::Path;
 use std::rc::Rc;
+use std::{any::Any, cell::RefCell};

 use anyhow::{Context as _, Result};
 use gpui::{App, AppContext as _, AsyncApp, Entity, Task, WeakEntity};
@@ -40,12 +42,13 @@ impl AcpConnection {
            .current_dir(root_dir)
            .stdin(std::process::Stdio::piped())
            .stdout(std::process::Stdio::piped())
-            .stderr(std::process::Stdio::inherit())
+            .stderr(std::process::Stdio::piped())
            .kill_on_drop(true)
            .spawn()?;

-        let stdout = child.stdout.take().expect("Failed to take stdout");
-        let stdin = child.stdin.take().expect("Failed to take stdin");
+        let stdout = child.stdout.take().context("Failed to take stdout")?;
+        let stdin = child.stdin.take().context("Failed to take stdin")?;
+        let stderr = child.stderr.take().context("Failed to take stderr")?;
        log::trace!("Spawned (pid: {})", child.id());

        let sessions = Rc::new(RefCell::new(HashMap::default()));
@@ -63,6 +66,18 @@ impl AcpConnection {

        let io_task = cx.background_spawn(io_task);

+        cx.background_spawn(async move {
+            let mut stderr = BufReader::new(stderr);
+            let mut line = String::new();
+            while let Ok(n) = stderr.read_line(&mut line).await
+                && n > 0
+            {
+                log::warn!("agent stderr: {}", &line);
+                line.clear();
+            }
+        })
+        .detach();
+
        cx.spawn({
            let sessions = sessions.clone();
            async move |cx| {
@@ -111,7 +126,7 @@ impl AgentConnection for AcpConnection {
        self: Rc<Self>,
        project: Entity<Project>,
        cwd: &Path,
-        cx: &mut AsyncApp,
+        cx: &mut App,
    ) -> Task<Result<Entity<AcpThread>>> {
        let conn = self.connection.clone();
        let sessions = self.sessions.clone();
@@ -171,6 +186,7 @@ impl AgentConnection for AcpConnection {

    fn prompt(
        &self,
+        _id: Option<acp_thread::UserMessageId>,
        params: acp::PromptRequest,
        cx: &mut App,
    ) -> Task<Result<acp::PromptResponse>> {
@@ -190,6 +206,10 @@ impl AgentConnection for AcpConnection {
            .spawn(async move { conn.cancel(params).await })
            .detach();
    }
+
+    fn into_any(self: Rc<Self>) -> Rc<dyn Any> {
+        self
+    }
 }

 struct ClientDelegate {
@@ -213,7 +233,7 @@ impl acp::Client for ClientDelegate {
                thread.request_tool_call_authorization(arguments.tool_call, arguments.options, cx)
            })?;

-        let result = rx.await;
+        let result = rx?.await;

        let outcome = match result {
            Ok(option) => acp::RequestPermissionOutcome::Selected { option_id: option },
--- a/crates/agent_servers/src/claude.rs
+++ b/crates/agent_servers/src/claude.rs
@@ -6,6 +6,7 @@ use context_server::listener::McpServerTool;
 use project::Project;
 use settings::SettingsStore;
 use smol::process::Child;
+use std::any::Any;
 use std::cell::RefCell;
 use std::fmt::Display;
 use std::path::Path;
@@ -13,7 +14,7 @@ use std::rc::Rc;
 use uuid::Uuid;

 use agent_client_protocol as acp;
-use anyhow::{Result, anyhow};
+use anyhow::{Context as _, Result, anyhow};
 use futures::channel::oneshot;
 use futures::{AsyncBufReadExt, AsyncWriteExt};
 use futures::{
@@ -74,7 +75,7 @@ impl AgentConnection for ClaudeAgentConnection {
        self: Rc<Self>,
        project: Entity<Project>,
        cwd: &Path,
-        cx: &mut AsyncApp,
+        cx: &mut App,
    ) -> Task<Result<Entity<AcpThread>>> {
        let cwd = cwd.to_owned();
        cx.spawn(async move |cx| {
@@ -129,12 +130,25 @@ impl AgentConnection for ClaudeAgentConnection {
                &cwd,
            )?;

-            let stdin = child.stdin.take().unwrap();
-            let stdout = child.stdout.take().unwrap();
+            let stdout = child.stdout.take().context("Failed to take stdout")?;
+            let stdin = child.stdin.take().context("Failed to take stdin")?;
+            let stderr = child.stderr.take().context("Failed to take stderr")?;

            let pid = child.id();
            log::trace!("Spawned (pid: {})", pid);

+            cx.background_spawn(async move {
+                let mut stderr = BufReader::new(stderr);
+                let mut line = String::new();
+                while let Ok(n) = stderr.read_line(&mut line).await
+                    && n > 0
+                {
+                    log::warn!("agent stderr: {}", &line);
+                    line.clear();
+                }
+            })
+            .detach();
+
            cx.background_spawn(async move {
                let mut outgoing_rx = Some(outgoing_rx);

@@ -210,6 +224,7 @@ impl AgentConnection for ClaudeAgentConnection {

    fn prompt(
        &self,
+        _id: Option<acp_thread::UserMessageId>,
        params: acp::PromptRequest,
        cx: &mut App,
    ) -> Task<Result<acp::PromptResponse>> {
@@ -288,6 +303,10 @@ impl AgentConnection for ClaudeAgentConnection {
            })
            .log_err();
    }
+
+    fn into_any(self: Rc<Self>) -> Rc<dyn Any> {
+        self
+    }
 }

 #[derive(Clone, Copy)]
@@ -339,7 +358,7 @@ fn spawn_claude(
        .current_dir(root_dir)
        .stdin(std::process::Stdio::piped())
        .stdout(std::process::Stdio::piped())
-        .stderr(std::process::Stdio::inherit())
+        .stderr(std::process::Stdio::piped())
        .kill_on_drop(true)
        .spawn()?;

@@ -423,7 +442,7 @@ impl ClaudeAgentSession {
                            if !turn_state.borrow().is_cancelled() {
                                thread
                                    .update(cx, |thread, cx| {
-                                        thread.push_user_content_block(text.into(), cx)
+                                        thread.push_user_content_block(None, text.into(), cx)
                                    })
                                    .log_err();
                            }
@@ -541,8 +560,9 @@ impl ClaudeAgentSession {
                                        thread.upsert_tool_call(
                                            claude_tool.as_acp(acp::ToolCallId(id.into())),
                                            cx,
-                                        );
+                                        )?;
                                    }
+                                    anyhow::Ok(())
                                })
                                .log_err();
                        }
--- a/crates/agent_servers/src/claude/mcp_server.rs
+++ b/crates/agent_servers/src/claude/mcp_server.rs
@@ -154,7 +154,7 @@ impl McpServerTool for PermissionTool {
        let chosen_option = thread
            .update(cx, |thread, cx| {
                thread.request_tool_call_authorization(
-                    claude_tool.as_acp(tool_call_id),
+                    claude_tool.as_acp(tool_call_id).into(),
                    vec![
                        acp::PermissionOption {
                            id: allow_option_id.clone(),
@@ -169,7 +169,7 @@ impl McpServerTool for PermissionTool {
                    ],
                    cx,
                )
-            })?
+            })??
            .await?;

        let response = if chosen_option == allow_option_id {
--- a/crates/agent_servers/src/e2e_tests.rs
+++ b/crates/agent_servers/src/e2e_tests.rs
@@ -422,8 +422,8 @@ pub async fn new_test_thread(
        .await
        .unwrap();

-    let thread = connection
-        .new_thread(project.clone(), current_dir.as_ref(), &mut cx.to_async())
+    let thread = cx
+        .update(|cx| connection.new_thread(project.clone(), current_dir.as_ref(), cx))
        .await
        .unwrap();

--- a/crates/agent_settings/src/agent_settings.rs
+++ b/crates/agent_settings/src/agent_settings.rs
@@ -309,7 +309,7 @@ pub struct AgentSettingsContent {
    ///
    /// Default: true
    expand_terminal_card: Option<bool>,
-    /// Whether to always use cmd-enter (or ctrl-enter on Linux) to send messages in the agent panel.
+    /// Whether to always use cmd-enter (or ctrl-enter on Linux or Windows) to send messages in the agent panel.
    ///
    /// Default: false
    use_modifier_to_send: Option<bool>,
--- a/crates/agent_ui/Cargo.toml
+++ b/crates/agent_ui/Cargo.toml
@@ -50,7 +50,6 @@ fuzzy.workspace = true
 gpui.workspace = true
 html_to_markdown.workspace = true
 http_client.workspace = true
-indexed_docs.workspace = true
 indoc.workspace = true
 inventory.workspace = true
 itertools.workspace = true
@@ -93,6 +92,7 @@ time.workspace = true
 time_format.workspace = true
 ui.workspace = true
 ui_input.workspace = true
+url.workspace = true
 urlencoding.workspace = true
 util.workspace = true
 uuid.workspace = true
@@ -102,6 +102,9 @@ workspace.workspace = true
 zed_actions.workspace = true

 [dev-dependencies]
+acp_thread = { workspace = true, features = ["test-support"] }
+agent = { workspace = true, features = ["test-support"] }
+assistant_context = { workspace = true, features = ["test-support"] }
 assistant_tools.workspace = true
 buffer_diff = { workspace = true, features = ["test-support"] }
 editor = { workspace = true, features = ["test-support"] }
--- a/crates/agent_ui/src/acp.rs
+++ b/crates/agent_ui/src/acp.rs
@@ -1,6 +1,10 @@
 mod completion_provider;
-mod message_history;
+mod entry_view_state;
+mod message_editor;
+mod model_selector;
+mod model_selector_popover;
 mod thread_view;

-pub use message_history::MessageHistory;
+pub use model_selector::AcpModelSelector;
+pub use model_selector_popover::AcpModelSelectorPopover;
 pub use thread_view::AcpThreadView;
--- a/crates/agent_ui/src/acp/completion_provider.rs
+++ b/crates/agent_ui/src/acp/completion_provider.rs
--- a/crates/agent_ui/src/acp/entry_view_state.rs
+++ b/crates/agent_ui/src/acp/entry_view_state.rs
@@ -0,0 +1,444 @@
+use std::ops::Range;
+
+use acp_thread::{AcpThread, AgentThreadEntry};
+use agent::{TextThreadStore, ThreadStore};
+use collections::HashMap;
+use editor::{Editor, EditorMode, MinimapVisibility};
+use gpui::{
+    AnyEntity, App, AppContext as _, Entity, EntityId, EventEmitter, TextStyleRefinement,
+    WeakEntity, Window,
+};
+use language::language_settings::SoftWrap;
+use project::Project;
+use settings::Settings as _;
+use terminal_view::TerminalView;
+use theme::ThemeSettings;
+use ui::{Context, TextSize};
+use workspace::Workspace;
+
+use crate::acp::message_editor::{MessageEditor, MessageEditorEvent};
+
+pub struct EntryViewState {
+    workspace: WeakEntity<Workspace>,
+    project: Entity<Project>,
+    thread_store: Entity<ThreadStore>,
+    text_thread_store: Entity<TextThreadStore>,
+    entries: Vec<Entry>,
+}
+
+impl EntryViewState {
+    pub fn new(
+        workspace: WeakEntity<Workspace>,
+        project: Entity<Project>,
+        thread_store: Entity<ThreadStore>,
+        text_thread_store: Entity<TextThreadStore>,
+    ) -> Self {
+        Self {
+            workspace,
+            project,
+            thread_store,
+            text_thread_store,
+            entries: Vec::new(),
+        }
+    }
+
+    pub fn entry(&self, index: usize) -> Option<&Entry> {
+        self.entries.get(index)
+    }
+
+    pub fn sync_entry(
+        &mut self,
+        index: usize,
+        thread: &Entity<AcpThread>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(thread_entry) = thread.read(cx).entries().get(index) else {
+            return;
+        };
+
+        match thread_entry {
+            AgentThreadEntry::UserMessage(message) => {
+                let has_id = message.id.is_some();
+                let chunks = message.chunks.clone();
+                let message_editor = cx.new(|cx| {
+                    let mut editor = MessageEditor::new(
+                        self.workspace.clone(),
+                        self.project.clone(),
+                        self.thread_store.clone(),
+                        self.text_thread_store.clone(),
+                        editor::EditorMode::AutoHeight {
+                            min_lines: 1,
+                            max_lines: None,
+                        },
+                        window,
+                        cx,
+                    );
+                    if !has_id {
+                        editor.set_read_only(true, cx);
+                    }
+                    editor.set_message(chunks, window, cx);
+                    editor
+                });
+                cx.subscribe(&message_editor, move |_, editor, event, cx| {
+                    cx.emit(EntryViewEvent {
+                        entry_index: index,
+                        view_event: ViewEvent::MessageEditorEvent(editor, *event),
+                    })
+                })
+                .detach();
+                self.set_entry(index, Entry::UserMessage(message_editor));
+            }
+            AgentThreadEntry::ToolCall(tool_call) => {
+                let terminals = tool_call.terminals().cloned().collect::<Vec<_>>();
+                let diffs = tool_call.diffs().cloned().collect::<Vec<_>>();
+
+                let views = if let Some(Entry::Content(views)) = self.entries.get_mut(index) {
+                    views
+                } else {
+                    self.set_entry(index, Entry::empty());
+                    let Some(Entry::Content(views)) = self.entries.get_mut(index) else {
+                        unreachable!()
+                    };
+                    views
+                };
+
+                for terminal in terminals {
+                    views.entry(terminal.entity_id()).or_insert_with(|| {
+                        create_terminal(
+                            self.workspace.clone(),
+                            self.project.clone(),
+                            terminal.clone(),
+                            window,
+                            cx,
+                        )
+                        .into_any()
+                    });
+                }
+
+                for diff in diffs {
+                    views
+                        .entry(diff.entity_id())
+                        .or_insert_with(|| create_editor_diff(diff.clone(), window, cx).into_any());
+                }
+            }
+            AgentThreadEntry::AssistantMessage(_) => {
+                if index == self.entries.len() {
+                    self.entries.push(Entry::empty())
+                }
+            }
+        };
+    }
+
+    fn set_entry(&mut self, index: usize, entry: Entry) {
+        if index == self.entries.len() {
+            self.entries.push(entry);
+        } else {
+            self.entries[index] = entry;
+        }
+    }
+
+    pub fn remove(&mut self, range: Range<usize>) {
+        self.entries.drain(range);
+    }
+
+    pub fn settings_changed(&mut self, cx: &mut App) {
+        for entry in self.entries.iter() {
+            match entry {
+                Entry::UserMessage { .. } => {}
+                Entry::Content(response_views) => {
+                    for view in response_views.values() {
+                        if let Ok(diff_editor) = view.clone().downcast::<Editor>() {
+                            diff_editor.update(cx, |diff_editor, cx| {
+                                diff_editor.set_text_style_refinement(
+                                    diff_editor_text_style_refinement(cx),
+                                );
+                                cx.notify();
+                            })
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+impl EventEmitter<EntryViewEvent> for EntryViewState {}
+
+pub struct EntryViewEvent {
+    pub entry_index: usize,
+    pub view_event: ViewEvent,
+}
+
+pub enum ViewEvent {
+    MessageEditorEvent(Entity<MessageEditor>, MessageEditorEvent),
+}
+
+pub enum Entry {
+    UserMessage(Entity<MessageEditor>),
+    Content(HashMap<EntityId, AnyEntity>),
+}
+
+impl Entry {
+    pub fn message_editor(&self) -> Option<&Entity<MessageEditor>> {
+        match self {
+            Self::UserMessage(editor) => Some(editor),
+            Entry::Content(_) => None,
+        }
+    }
+
+    pub fn editor_for_diff(&self, diff: &Entity<acp_thread::Diff>) -> Option<Entity<Editor>> {
+        self.content_map()?
+            .get(&diff.entity_id())
+            .cloned()
+            .map(|entity| entity.downcast::<Editor>().unwrap())
+    }
+
+    pub fn terminal(
+        &self,
+        terminal: &Entity<acp_thread::Terminal>,
+    ) -> Option<Entity<TerminalView>> {
+        self.content_map()?
+            .get(&terminal.entity_id())
+            .cloned()
+            .map(|entity| entity.downcast::<TerminalView>().unwrap())
+    }
+
+    fn content_map(&self) -> Option<&HashMap<EntityId, AnyEntity>> {
+        match self {
+            Self::Content(map) => Some(map),
+            _ => None,
+        }
+    }
+
+    fn empty() -> Self {
+        Self::Content(HashMap::default())
+    }
+
+    #[cfg(test)]
+    pub fn has_content(&self) -> bool {
+        match self {
+            Self::Content(map) => !map.is_empty(),
+            Self::UserMessage(_) => false,
+        }
+    }
+}
+
+fn create_terminal(
+    workspace: WeakEntity<Workspace>,
+    project: Entity<Project>,
+    terminal: Entity<acp_thread::Terminal>,
+    window: &mut Window,
+    cx: &mut App,
+) -> Entity<TerminalView> {
+    cx.new(|cx| {
+        let mut view = TerminalView::new(
+            terminal.read(cx).inner().clone(),
+            workspace.clone(),
+            None,
+            project.downgrade(),
+            window,
+            cx,
+        );
+        view.set_embedded_mode(Some(1000), cx);
+        view
+    })
+}
+
+fn create_editor_diff(
+    diff: Entity<acp_thread::Diff>,
+    window: &mut Window,
+    cx: &mut App,
+) -> Entity<Editor> {
+    cx.new(|cx| {
+        let mut editor = Editor::new(
+            EditorMode::Full {
+                scale_ui_elements_with_buffer_font_size: false,
+                show_active_line_background: false,
+                sized_by_content: true,
+            },
+            diff.read(cx).multibuffer().clone(),
+            None,
+            window,
+            cx,
+        );
+        editor.set_show_gutter(false, cx);
+        editor.disable_inline_diagnostics();
+        editor.disable_expand_excerpt_buttons(cx);
+        editor.set_show_vertical_scrollbar(false, cx);
+        editor.set_minimap_visibility(MinimapVisibility::Disabled, window, cx);
+        editor.set_soft_wrap_mode(SoftWrap::None, cx);
+        editor.scroll_manager.set_forbid_vertical_scroll(true);
+        editor.set_show_indent_guides(false, cx);
+        editor.set_read_only(true);
+        editor.set_show_breakpoints(false, cx);
+        editor.set_show_code_actions(false, cx);
+        editor.set_show_git_diff_gutter(false, cx);
+        editor.set_expand_all_diff_hunks(cx);
+        editor.set_text_style_refinement(diff_editor_text_style_refinement(cx));
+        editor
+    })
+}
+
+fn diff_editor_text_style_refinement(cx: &mut App) -> TextStyleRefinement {
+    TextStyleRefinement {
+        font_size: Some(
+            TextSize::Small
+                .rems(cx)
+                .to_pixels(ThemeSettings::get_global(cx).agent_font_size(cx))
+                .into(),
+        ),
+        ..Default::default()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{path::Path, rc::Rc};
+
+    use acp_thread::{AgentConnection, StubAgentConnection};
+    use agent::{TextThreadStore, ThreadStore};
+    use agent_client_protocol as acp;
+    use agent_settings::AgentSettings;
+    use buffer_diff::{DiffHunkStatus, DiffHunkStatusKind};
+    use editor::{EditorSettings, RowInfo};
+    use fs::FakeFs;
+    use gpui::{AppContext as _, SemanticVersion, TestAppContext};
+
+    use crate::acp::entry_view_state::EntryViewState;
+    use multi_buffer::MultiBufferRow;
+    use pretty_assertions::assert_matches;
+    use project::Project;
+    use serde_json::json;
+    use settings::{Settings as _, SettingsStore};
+    use theme::ThemeSettings;
+    use util::path;
+    use workspace::Workspace;
+
+    #[gpui::test]
+    async fn test_diff_sync(cx: &mut TestAppContext) {
+        init_test(cx);
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree(
+            "/project",
+            json!({
+                "hello.txt": "hi world"
+            }),
+        )
+        .await;
+        let project = Project::test(fs, [Path::new(path!("/project"))], cx).await;
+
+        let (workspace, cx) =
+            cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
+
+        let tool_call = acp::ToolCall {
+            id: acp::ToolCallId("tool".into()),
+            title: "Tool call".into(),
+            kind: acp::ToolKind::Other,
+            status: acp::ToolCallStatus::InProgress,
+            content: vec![acp::ToolCallContent::Diff {
+                diff: acp::Diff {
+                    path: "/project/hello.txt".into(),
+                    old_text: Some("hi world".into()),
+                    new_text: "hello world".into(),
+                },
+            }],
+            locations: vec![],
+            raw_input: None,
+            raw_output: None,
+        };
+        let connection = Rc::new(StubAgentConnection::new());
+        let thread = cx
+            .update(|_, cx| {
+                connection
+                    .clone()
+                    .new_thread(project.clone(), Path::new(path!("/project")), cx)
+            })
+            .await
+            .unwrap();
+        let session_id = thread.update(cx, |thread, _| thread.session_id().clone());
+
+        cx.update(|_, cx| {
+            connection.send_update(session_id, acp::SessionUpdate::ToolCall(tool_call), cx)
+        });
+
+        let thread_store = cx.new(|cx| ThreadStore::fake(project.clone(), cx));
+        let text_thread_store = cx.new(|cx| TextThreadStore::fake(project.clone(), cx));
+
+        let view_state = cx.new(|_cx| {
+            EntryViewState::new(
+                workspace.downgrade(),
+                project.clone(),
+                thread_store,
+                text_thread_store,
+            )
+        });
+
+        view_state.update_in(cx, |view_state, window, cx| {
+            view_state.sync_entry(0, &thread, window, cx)
+        });
+
+        let diff = thread.read_with(cx, |thread, _cx| {
+            thread
+                .entries()
+                .get(0)
+                .unwrap()
+                .diffs()
+                .next()
+                .unwrap()
+                .clone()
+        });
+
+        cx.run_until_parked();
+
+        let diff_editor = view_state.read_with(cx, |view_state, _cx| {
+            view_state.entry(0).unwrap().editor_for_diff(&diff).unwrap()
+        });
+        assert_eq!(
+            diff_editor.read_with(cx, |editor, cx| editor.text(cx)),
+            "hi world\nhello world"
+        );
+        let row_infos = diff_editor.read_with(cx, |editor, cx| {
+            let multibuffer = editor.buffer().read(cx);
+            multibuffer
+                .snapshot(cx)
+                .row_infos(MultiBufferRow(0))
+                .collect::<Vec<_>>()
+        });
+        assert_matches!(
+            row_infos.as_slice(),
+            [
+                RowInfo {
+                    multibuffer_row: Some(MultiBufferRow(0)),
+                    diff_status: Some(DiffHunkStatus {
+                        kind: DiffHunkStatusKind::Deleted,
+                        ..
+                    }),
+                    ..
+                },
+                RowInfo {
+                    multibuffer_row: Some(MultiBufferRow(1)),
+                    diff_status: Some(DiffHunkStatus {
+                        kind: DiffHunkStatusKind::Added,
+                        ..
+                    }),
+                    ..
+                }
+            ]
+        );
+    }
+
+    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);
+            AgentSettings::register(cx);
+            workspace::init_settings(cx);
+            ThemeSettings::register(cx);
+            release_channel::init(SemanticVersion::default(), cx);
+            EditorSettings::register(cx);
+        });
+    }
+}
--- a/crates/agent_ui/src/acp/message_editor.rs
+++ b/crates/agent_ui/src/acp/message_editor.rs
--- a/crates/agent_ui/src/acp/message_history.rs
+++ b/crates/agent_ui/src/acp/message_history.rs
@@ -1,92 +0,0 @@
-pub struct MessageHistory<T> {
-    items: Vec<T>,
-    current: Option<usize>,
-}
-
-impl<T> Default for MessageHistory<T> {
-    fn default() -> Self {
-        MessageHistory {
-            items: Vec::new(),
-            current: None,
-        }
-    }
-}
-
-impl<T> MessageHistory<T> {
-    pub fn push(&mut self, message: T) {
-        self.current.take();
-        self.items.push(message);
-    }
-
-    pub fn reset_position(&mut self) {
-        self.current.take();
-    }
-
-    pub fn prev(&mut self) -> Option<&T> {
-        if self.items.is_empty() {
-            return None;
-        }
-
-        let new_ix = self
-            .current
-            .get_or_insert(self.items.len())
-            .saturating_sub(1);
-
-        self.current = Some(new_ix);
-        self.items.get(new_ix)
-    }
-
-    pub fn next(&mut self) -> Option<&T> {
-        let current = self.current.as_mut()?;
-        *current += 1;
-
-        self.items.get(*current).or_else(|| {
-            self.current.take();
-            None
-        })
-    }
-
-    #[cfg(test)]
-    pub fn items(&self) -> &[T] {
-        &self.items
-    }
-}
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_prev_next() {
-        let mut history = MessageHistory::default();
-
-        // Test empty history
-        assert_eq!(history.prev(), None);
-        assert_eq!(history.next(), None);
-
-        // Add some messages
-        history.push("first");
-        history.push("second");
-        history.push("third");
-
-        // Test prev navigation
-        assert_eq!(history.prev(), Some(&"third"));
-        assert_eq!(history.prev(), Some(&"second"));
-        assert_eq!(history.prev(), Some(&"first"));
-        assert_eq!(history.prev(), Some(&"first"));
-
-        assert_eq!(history.next(), Some(&"second"));
-
-        // Test mixed navigation
-        history.push("fourth");
-        assert_eq!(history.prev(), Some(&"fourth"));
-        assert_eq!(history.prev(), Some(&"third"));
-        assert_eq!(history.next(), Some(&"fourth"));
-        assert_eq!(history.next(), None);
-
-        // Test that push resets navigation
-        history.prev();
-        history.prev();
-        history.push("fifth");
-        assert_eq!(history.prev(), Some(&"fifth"));
-    }
-}
--- a/crates/agent_ui/src/acp/model_selector.rs
+++ b/crates/agent_ui/src/acp/model_selector.rs
@@ -0,0 +1,472 @@
+use std::{cmp::Reverse, rc::Rc, sync::Arc};
+
+use acp_thread::{AgentModelInfo, AgentModelList, AgentModelSelector};
+use agent_client_protocol as acp;
+use anyhow::Result;
+use collections::IndexMap;
+use futures::FutureExt;
+use fuzzy::{StringMatchCandidate, match_strings};
+use gpui::{Action, AsyncWindowContext, BackgroundExecutor, DismissEvent, Task, WeakEntity};
+use ordered_float::OrderedFloat;
+use picker::{Picker, PickerDelegate};
+use ui::{
+    AnyElement, App, Context, IntoElement, ListItem, ListItemSpacing, SharedString, Window,
+    prelude::*, rems,
+};
+use util::ResultExt;
+
+pub type AcpModelSelector = Picker<AcpModelPickerDelegate>;
+
+pub fn acp_model_selector(
+    session_id: acp::SessionId,
+    selector: Rc<dyn AgentModelSelector>,
+    window: &mut Window,
+    cx: &mut Context<AcpModelSelector>,
+) -> AcpModelSelector {
+    let delegate = AcpModelPickerDelegate::new(session_id, selector, window, cx);
+    Picker::list(delegate, window, cx)
+        .show_scrollbar(true)
+        .width(rems(20.))
+        .max_height(Some(rems(20.).into()))
+}
+
+enum AcpModelPickerEntry {
+    Separator(SharedString),
+    Model(AgentModelInfo),
+}
+
+pub struct AcpModelPickerDelegate {
+    session_id: acp::SessionId,
+    selector: Rc<dyn AgentModelSelector>,
+    filtered_entries: Vec<AcpModelPickerEntry>,
+    models: Option<AgentModelList>,
+    selected_index: usize,
+    selected_model: Option<AgentModelInfo>,
+    _refresh_models_task: Task<()>,
+}
+
+impl AcpModelPickerDelegate {
+    fn new(
+        session_id: acp::SessionId,
+        selector: Rc<dyn AgentModelSelector>,
+        window: &mut Window,
+        cx: &mut Context<AcpModelSelector>,
+    ) -> Self {
+        let mut rx = selector.watch(cx);
+        let refresh_models_task = cx.spawn_in(window, {
+            let session_id = session_id.clone();
+            async move |this, cx| {
+                async fn refresh(
+                    this: &WeakEntity<Picker<AcpModelPickerDelegate>>,
+                    session_id: &acp::SessionId,
+                    cx: &mut AsyncWindowContext,
+                ) -> Result<()> {
+                    let (models_task, selected_model_task) = this.update(cx, |this, cx| {
+                        (
+                            this.delegate.selector.list_models(cx),
+                            this.delegate.selector.selected_model(session_id, cx),
+                        )
+                    })?;
+
+                    let (models, selected_model) = futures::join!(models_task, selected_model_task);
+
+                    this.update_in(cx, |this, window, cx| {
+                        this.delegate.models = models.ok();
+                        this.delegate.selected_model = selected_model.ok();
+                        this.delegate.update_matches(this.query(cx), window, cx)
+                    })?
+                    .await;
+
+                    Ok(())
+                }
+
+                refresh(&this, &session_id, cx).await.log_err();
+                while let Ok(()) = rx.recv().await {
+                    refresh(&this, &session_id, cx).await.log_err();
+                }
+            }
+        });
+
+        Self {
+            session_id,
+            selector,
+            filtered_entries: Vec::new(),
+            models: None,
+            selected_model: None,
+            selected_index: 0,
+            _refresh_models_task: refresh_models_task,
+        }
+    }
+
+    pub fn active_model(&self) -> Option<&AgentModelInfo> {
+        self.selected_model.as_ref()
+    }
+}
+
+impl PickerDelegate for AcpModelPickerDelegate {
+    type ListItem = AnyElement;
+
+    fn match_count(&self) -> usize {
+        self.filtered_entries.len()
+    }
+
+    fn selected_index(&self) -> usize {
+        self.selected_index
+    }
+
+    fn set_selected_index(&mut self, ix: usize, _: &mut Window, cx: &mut Context<Picker<Self>>) {
+        self.selected_index = ix.min(self.filtered_entries.len().saturating_sub(1));
+        cx.notify();
+    }
+
+    fn can_select(
+        &mut self,
+        ix: usize,
+        _window: &mut Window,
+        _cx: &mut Context<Picker<Self>>,
+    ) -> bool {
+        match self.filtered_entries.get(ix) {
+            Some(AcpModelPickerEntry::Model(_)) => true,
+            Some(AcpModelPickerEntry::Separator(_)) | None => false,
+        }
+    }
+
+    fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> Arc<str> {
+        "Select a model…".into()
+    }
+
+    fn update_matches(
+        &mut self,
+        query: String,
+        window: &mut Window,
+        cx: &mut Context<Picker<Self>>,
+    ) -> Task<()> {
+        cx.spawn_in(window, async move |this, cx| {
+            let filtered_models = match this
+                .read_with(cx, |this, cx| {
+                    this.delegate.models.clone().map(move |models| {
+                        fuzzy_search(models, query, cx.background_executor().clone())
+                    })
+                })
+                .ok()
+                .flatten()
+            {
+                Some(task) => task.await,
+                None => AgentModelList::Flat(vec![]),
+            };
+
+            this.update_in(cx, |this, window, cx| {
+                this.delegate.filtered_entries =
+                    info_list_to_picker_entries(filtered_models).collect();
+                // Finds the currently selected model in the list
+                let new_index = this
+                    .delegate
+                    .selected_model
+                    .as_ref()
+                    .and_then(|selected| {
+                        this.delegate.filtered_entries.iter().position(|entry| {
+                            if let AcpModelPickerEntry::Model(model_info) = entry {
+                                model_info.id == selected.id
+                            } else {
+                                false
+                            }
+                        })
+                    })
+                    .unwrap_or(0);
+                this.set_selected_index(new_index, Some(picker::Direction::Down), true, window, cx);
+                cx.notify();
+            })
+            .ok();
+        })
+    }
+
+    fn confirm(&mut self, _secondary: bool, window: &mut Window, cx: &mut Context<Picker<Self>>) {
+        if let Some(AcpModelPickerEntry::Model(model_info)) =
+            self.filtered_entries.get(self.selected_index)
+        {
+            self.selector
+                .select_model(self.session_id.clone(), model_info.id.clone(), cx)
+                .detach_and_log_err(cx);
+            self.selected_model = Some(model_info.clone());
+            let current_index = self.selected_index;
+            self.set_selected_index(current_index, window, cx);
+
+            cx.emit(DismissEvent);
+        }
+    }
+
+    fn dismissed(&mut self, _: &mut Window, cx: &mut Context<Picker<Self>>) {
+        cx.emit(DismissEvent);
+    }
+
+    fn render_match(
+        &self,
+        ix: usize,
+        selected: bool,
+        _: &mut Window,
+        cx: &mut Context<Picker<Self>>,
+    ) -> Option<Self::ListItem> {
+        match self.filtered_entries.get(ix)? {
+            AcpModelPickerEntry::Separator(title) => Some(
+                div()
+                    .px_2()
+                    .pb_1()
+                    .when(ix > 1, |this| {
+                        this.mt_1()
+                            .pt_2()
+                            .border_t_1()
+                            .border_color(cx.theme().colors().border_variant)
+                    })
+                    .child(
+                        Label::new(title)
+                            .size(LabelSize::XSmall)
+                            .color(Color::Muted),
+                    )
+                    .into_any_element(),
+            ),
+            AcpModelPickerEntry::Model(model_info) => {
+                let is_selected = Some(model_info) == self.selected_model.as_ref();
+
+                let model_icon_color = if is_selected {
+                    Color::Accent
+                } else {
+                    Color::Muted
+                };
+
+                Some(
+                    ListItem::new(ix)
+                        .inset(true)
+                        .spacing(ListItemSpacing::Sparse)
+                        .toggle_state(selected)
+                        .start_slot::<Icon>(model_info.icon.map(|icon| {
+                            Icon::new(icon)
+                                .color(model_icon_color)
+                                .size(IconSize::Small)
+                        }))
+                        .child(
+                            h_flex()
+                                .w_full()
+                                .pl_0p5()
+                                .gap_1p5()
+                                .w(px(240.))
+                                .child(Label::new(model_info.name.clone()).truncate()),
+                        )
+                        .end_slot(div().pr_3().when(is_selected, |this| {
+                            this.child(
+                                Icon::new(IconName::Check)
+                                    .color(Color::Accent)
+                                    .size(IconSize::Small),
+                            )
+                        }))
+                        .into_any_element(),
+                )
+            }
+        }
+    }
+
+    fn render_footer(
+        &self,
+        _: &mut Window,
+        cx: &mut Context<Picker<Self>>,
+    ) -> Option<gpui::AnyElement> {
+        Some(
+            h_flex()
+                .w_full()
+                .border_t_1()
+                .border_color(cx.theme().colors().border_variant)
+                .p_1()
+                .gap_4()
+                .justify_between()
+                .child(
+                    Button::new("configure", "Configure")
+                        .icon(IconName::Settings)
+                        .icon_size(IconSize::Small)
+                        .icon_color(Color::Muted)
+                        .icon_position(IconPosition::Start)
+                        .on_click(|_, window, cx| {
+                            window.dispatch_action(
+                                zed_actions::agent::OpenSettings.boxed_clone(),
+                                cx,
+                            );
+                        }),
+                )
+                .into_any(),
+        )
+    }
+}
+
+fn info_list_to_picker_entries(
+    model_list: AgentModelList,
+) -> impl Iterator<Item = AcpModelPickerEntry> {
+    match model_list {
+        AgentModelList::Flat(list) => {
+            itertools::Either::Left(list.into_iter().map(AcpModelPickerEntry::Model))
+        }
+        AgentModelList::Grouped(index_map) => {
+            itertools::Either::Right(index_map.into_iter().flat_map(|(group_name, models)| {
+                std::iter::once(AcpModelPickerEntry::Separator(group_name.0))
+                    .chain(models.into_iter().map(AcpModelPickerEntry::Model))
+            }))
+        }
+    }
+}
+
+async fn fuzzy_search(
+    model_list: AgentModelList,
+    query: String,
+    executor: BackgroundExecutor,
+) -> AgentModelList {
+    async fn fuzzy_search_list(
+        model_list: Vec<AgentModelInfo>,
+        query: &str,
+        executor: BackgroundExecutor,
+    ) -> Vec<AgentModelInfo> {
+        let candidates = model_list
+            .iter()
+            .enumerate()
+            .map(|(ix, model)| {
+                StringMatchCandidate::new(ix, &format!("{}/{}", model.id, model.name))
+            })
+            .collect::<Vec<_>>();
+        let mut matches = match_strings(
+            &candidates,
+            &query,
+            false,
+            true,
+            100,
+            &Default::default(),
+            executor,
+        )
+        .await;
+
+        matches.sort_unstable_by_key(|mat| {
+            let candidate = &candidates[mat.candidate_id];
+            (Reverse(OrderedFloat(mat.score)), candidate.id)
+        });
+
+        matches
+            .into_iter()
+            .map(|mat| model_list[mat.candidate_id].clone())
+            .collect()
+    }
+
+    match model_list {
+        AgentModelList::Flat(model_list) => {
+            AgentModelList::Flat(fuzzy_search_list(model_list, &query, executor).await)
+        }
+        AgentModelList::Grouped(index_map) => {
+            let groups =
+                futures::future::join_all(index_map.into_iter().map(|(group_name, models)| {
+                    fuzzy_search_list(models, &query, executor.clone())
+                        .map(|results| (group_name, results))
+                }))
+                .await;
+            AgentModelList::Grouped(IndexMap::from_iter(
+                groups
+                    .into_iter()
+                    .filter(|(_, results)| !results.is_empty()),
+            ))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use gpui::TestAppContext;
+
+    use super::*;
+
+    fn create_model_list(grouped_models: Vec<(&str, Vec<&str>)>) -> AgentModelList {
+        AgentModelList::Grouped(IndexMap::from_iter(grouped_models.into_iter().map(
+            |(group, models)| {
+                (
+                    acp_thread::AgentModelGroupName(group.to_string().into()),
+                    models
+                        .into_iter()
+                        .map(|model| acp_thread::AgentModelInfo {
+                            id: acp_thread::AgentModelId(model.to_string().into()),
+                            name: model.to_string().into(),
+                            icon: None,
+                        })
+                        .collect::<Vec<_>>(),
+                )
+            },
+        )))
+    }
+
+    fn assert_models_eq(result: AgentModelList, expected: Vec<(&str, Vec<&str>)>) {
+        let AgentModelList::Grouped(groups) = result else {
+            panic!("Expected LanguageModelInfoList::Grouped, got {:?}", result);
+        };
+
+        assert_eq!(
+            groups.len(),
+            expected.len(),
+            "Number of groups doesn't match"
+        );
+
+        for (i, (expected_group, expected_models)) in expected.iter().enumerate() {
+            let (actual_group, actual_models) = groups.get_index(i).unwrap();
+            assert_eq!(
+                actual_group.0.as_ref(),
+                *expected_group,
+                "Group at position {} doesn't match expected group",
+                i
+            );
+            assert_eq!(
+                actual_models.len(),
+                expected_models.len(),
+                "Number of models in group {} doesn't match",
+                expected_group
+            );
+
+            for (j, expected_model_name) in expected_models.iter().enumerate() {
+                assert_eq!(
+                    actual_models[j].name, *expected_model_name,
+                    "Model at position {} in group {} doesn't match expected model",
+                    j, expected_group
+                );
+            }
+        }
+    }
+
+    #[gpui::test]
+    async fn test_fuzzy_match(cx: &mut TestAppContext) {
+        let models = create_model_list(vec![
+            (
+                "zed",
+                vec![
+                    "Claude 3.7 Sonnet",
+                    "Claude 3.7 Sonnet Thinking",
+                    "gpt-4.1",
+                    "gpt-4.1-nano",
+                ],
+            ),
+            ("openai", vec!["gpt-3.5-turbo", "gpt-4.1", "gpt-4.1-nano"]),
+            ("ollama", vec!["mistral", "deepseek"]),
+        ]);
+
+        // Results should preserve models order whenever possible.
+        // In the case below, `zed/gpt-4.1` and `openai/gpt-4.1` have identical
+        // similarity scores, but `zed/gpt-4.1` was higher in the models list,
+        // so it should appear first in the results.
+        let results = fuzzy_search(models.clone(), "41".into(), cx.executor()).await;
+        assert_models_eq(
+            results,
+            vec![
+                ("zed", vec!["gpt-4.1", "gpt-4.1-nano"]),
+                ("openai", vec!["gpt-4.1", "gpt-4.1-nano"]),
+            ],
+        );
+
+        // Fuzzy search
+        let results = fuzzy_search(models.clone(), "4n".into(), cx.executor()).await;
+        assert_models_eq(
+            results,
+            vec![
+                ("zed", vec!["gpt-4.1-nano"]),
+                ("openai", vec!["gpt-4.1-nano"]),
+            ],
+        );
+    }
+}
--- a/crates/agent_ui/src/acp/model_selector_popover.rs
+++ b/crates/agent_ui/src/acp/model_selector_popover.rs
@@ -0,0 +1,85 @@
+use std::rc::Rc;
+
+use acp_thread::AgentModelSelector;
+use agent_client_protocol as acp;
+use gpui::{Entity, FocusHandle};
+use picker::popover_menu::PickerPopoverMenu;
+use ui::{
+    ButtonLike, Context, IntoElement, PopoverMenuHandle, SharedString, Tooltip, Window, prelude::*,
+};
+use zed_actions::agent::ToggleModelSelector;
+
+use crate::acp::{AcpModelSelector, model_selector::acp_model_selector};
+
+pub struct AcpModelSelectorPopover {
+    selector: Entity<AcpModelSelector>,
+    menu_handle: PopoverMenuHandle<AcpModelSelector>,
+    focus_handle: FocusHandle,
+}
+
+impl AcpModelSelectorPopover {
+    pub(crate) fn new(
+        session_id: acp::SessionId,
+        selector: Rc<dyn AgentModelSelector>,
+        menu_handle: PopoverMenuHandle<AcpModelSelector>,
+        focus_handle: FocusHandle,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        Self {
+            selector: cx.new(move |cx| acp_model_selector(session_id, selector, window, cx)),
+            menu_handle,
+            focus_handle,
+        }
+    }
+
+    pub fn toggle(&self, window: &mut Window, cx: &mut Context<Self>) {
+        self.menu_handle.toggle(window, cx);
+    }
+}
+
+impl Render for AcpModelSelectorPopover {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let model = self.selector.read(cx).delegate.active_model();
+        let model_name = model
+            .as_ref()
+            .map(|model| model.name.clone())
+            .unwrap_or_else(|| SharedString::from("Select a Model"));
+
+        let model_icon = model.as_ref().and_then(|model| model.icon);
+
+        let focus_handle = self.focus_handle.clone();
+
+        PickerPopoverMenu::new(
+            self.selector.clone(),
+            ButtonLike::new("active-model")
+                .when_some(model_icon, |this, icon| {
+                    this.child(Icon::new(icon).color(Color::Muted).size(IconSize::XSmall))
+                })
+                .child(
+                    Label::new(model_name)
+                        .color(Color::Muted)
+                        .size(LabelSize::Small)
+                        .ml_0p5(),
+                )
+                .child(
+                    Icon::new(IconName::ChevronDown)
+                        .color(Color::Muted)
+                        .size(IconSize::XSmall),
+                ),
+            move |window, cx| {
+                Tooltip::for_action_in(
+                    "Change Model",
+                    &ToggleModelSelector,
+                    &focus_handle,
+                    window,
+                    cx,
+                )
+            },
+            gpui::Corner::BottomRight,
+            cx,
+        )
+        .with_handle(self.menu_handle.clone())
+        .render(window, cx)
+    }
+}
--- a/crates/agent_ui/src/acp/thread_view.rs
+++ b/crates/agent_ui/src/acp/thread_view.rs
--- a/crates/agent_ui/src/agent_configuration.rs
+++ b/crates/agent_ui/src/agent_configuration.rs
@@ -465,7 +465,7 @@ impl AgentConfiguration {
            "modifier-send",
            "Use modifier to submit a message",
            Some(
-                "Make a modifier (cmd-enter on macOS, ctrl-enter on Linux) required to send messages.".into(),
+                "Make a modifier (cmd-enter on macOS, ctrl-enter on Linux or Windows) required to send messages.".into(),
            ),
            use_modifier_to_send,
            move |state, _window, cx| {
@@ -1035,7 +1035,6 @@ fn extension_only_provides_context_server(manifest: &ExtensionManifest) -> bool
        && manifest.grammars.is_empty()
        && manifest.language_servers.is_empty()
        && manifest.slash_commands.is_empty()
-        && manifest.indexed_docs_providers.is_empty()
        && manifest.snippets.is_none()
        && manifest.debug_locators.is_empty()
 }
--- a/crates/agent_ui/src/agent_diff.rs
+++ b/crates/agent_ui/src/agent_diff.rs
@@ -1521,7 +1521,8 @@ impl AgentDiff {
                    self.update_reviewing_editors(workspace, window, cx);
                }
            }
-            AcpThreadEvent::Stopped
+            AcpThreadEvent::EntriesRemoved(_)
+            | AcpThreadEvent::Stopped
            | AcpThreadEvent::ToolAuthorizationRequired
            | AcpThreadEvent::Error
            | AcpThreadEvent::ServerExited(_) => {}
--- a/crates/agent_ui/src/agent_panel.rs
+++ b/crates/agent_ui/src/agent_panel.rs
--- a/crates/agent_ui/src/agent_ui.rs
+++ b/crates/agent_ui/src/agent_ui.rs
@@ -5,7 +5,6 @@ mod agent_diff;
 mod agent_model_selector;
 mod agent_panel;
 mod buffer_codegen;
-mod burn_mode_tooltip;
 mod context_picker;
 mod context_server_configuration;
 mod context_strip;
@@ -64,6 +63,8 @@ actions!(
        NewTextThread,
        /// Toggles the context picker interface for adding files, symbols, or other context.
        ToggleContextPicker,
+        /// Toggles the menu to create new agent threads.
+        ToggleNewThreadMenu,
        /// Toggles the navigation menu for switching between threads and views.
        ToggleNavigationMenu,
        /// Toggles the options menu for agent settings and preferences.
@@ -155,11 +156,11 @@ enum ExternalAgent {
 }

 impl ExternalAgent {
-    pub fn server(&self) -> Rc<dyn agent_servers::AgentServer> {
+    pub fn server(&self, fs: Arc<dyn fs::Fs>) -> Rc<dyn agent_servers::AgentServer> {
        match self {
            ExternalAgent::Gemini => Rc::new(agent_servers::Gemini),
            ExternalAgent::ClaudeCode => Rc::new(agent_servers::ClaudeCode),
-            ExternalAgent::NativeAgent => Rc::new(agent2::NativeAgentServer),
+            ExternalAgent::NativeAgent => Rc::new(agent2::NativeAgentServer::new(fs)),
        }
    }
 }
@@ -241,7 +242,6 @@ pub fn init(
        client.telemetry().clone(),
        cx,
    );
-    indexed_docs::init(cx);
    cx.observe_new(move |workspace, window, cx| {
        ConfigureContextServerModal::register(workspace, language_registry.clone(), window, cx)
    })
@@ -408,12 +408,6 @@ fn update_slash_commands_from_settings(cx: &mut App) {
    let slash_command_registry = SlashCommandRegistry::global(cx);
    let settings = SlashCommandSettings::get_global(cx);

-    if settings.docs.enabled {
-        slash_command_registry.register_command(assistant_slash_commands::DocsSlashCommand, true);
-    } else {
-        slash_command_registry.unregister_command(assistant_slash_commands::DocsSlashCommand);
-    }
-
    if settings.cargo_workspace.enabled {
        slash_command_registry
            .register_command(assistant_slash_commands::CargoWorkspaceSlashCommand, true);
--- a/crates/agent_ui/src/burn_mode_tooltip.rs
+++ b/crates/agent_ui/src/burn_mode_tooltip.rs
@@ -1,61 +0,0 @@
-use gpui::{Context, FontWeight, IntoElement, Render, Window};
-use ui::{prelude::*, tooltip_container};
-
-pub struct BurnModeTooltip {
-    selected: bool,
-}
-
-impl BurnModeTooltip {
-    pub fn new() -> Self {
-        Self { selected: false }
-    }
-
-    pub fn selected(mut self, selected: bool) -> Self {
-        self.selected = selected;
-        self
-    }
-}
-
-impl Render for BurnModeTooltip {
-    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let (icon, color) = if self.selected {
-            (IconName::ZedBurnModeOn, Color::Error)
-        } else {
-            (IconName::ZedBurnMode, Color::Default)
-        };
-
-        let turned_on = h_flex()
-            .h_4()
-            .px_1()
-            .border_1()
-            .border_color(cx.theme().colors().border)
-            .bg(cx.theme().colors().text_accent.opacity(0.1))
-            .rounded_sm()
-            .child(
-                Label::new("ON")
-                    .size(LabelSize::XSmall)
-                    .weight(FontWeight::SEMIBOLD)
-                    .color(Color::Accent),
-            );
-
-        let title = h_flex()
-            .gap_1p5()
-            .child(Icon::new(icon).size(IconSize::Small).color(color))
-            .child(Label::new("Burn Mode"))
-            .when(self.selected, |title| title.child(turned_on));
-
-        tooltip_container(window, cx, |this, _, _| {
-            this
-                .child(title)
-                .child(
-                    div()
-                        .max_w_64()
-                        .child(
-                            Label::new("Enables models to use large context windows, unlimited tool calls, and other capabilities for expanded reasoning.")
-                                .size(LabelSize::Small)
-                                .color(Color::Muted)
-                        )
-                )
-        })
-    }
-}
--- a/crates/agent_ui/src/context_picker.rs
+++ b/crates/agent_ui/src/context_picker.rs
@@ -1,18 +1,19 @@
 mod completion_provider;
-mod fetch_context_picker;
+pub(crate) mod fetch_context_picker;
 pub(crate) mod file_context_picker;
-mod rules_context_picker;
-mod symbol_context_picker;
-mod thread_context_picker;
+pub(crate) mod rules_context_picker;
+pub(crate) mod symbol_context_picker;
+pub(crate) mod thread_context_picker;

 use std::ops::Range;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;

 use anyhow::{Result, anyhow};
+use collections::HashSet;
 pub use completion_provider::ContextPickerCompletionProvider;
 use editor::display_map::{Crease, CreaseId, CreaseMetadata, FoldId};
-use editor::{Anchor, AnchorRangeExt as _, Editor, ExcerptId, FoldPlaceholder, ToOffset};
+use editor::{Anchor, Editor, ExcerptId, FoldPlaceholder, ToOffset};
 use fetch_context_picker::FetchContextPicker;
 use file_context_picker::FileContextPicker;
 use file_context_picker::render_file_context_entry;
@@ -45,7 +46,7 @@ use agent::{
 };

 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum ContextPickerEntry {
+pub(crate) enum ContextPickerEntry {
    Mode(ContextPickerMode),
    Action(ContextPickerAction),
 }
@@ -74,7 +75,7 @@ impl ContextPickerEntry {
 }

 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum ContextPickerMode {
+pub(crate) enum ContextPickerMode {
    File,
    Symbol,
    Fetch,
@@ -83,7 +84,7 @@ enum ContextPickerMode {
 }

 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum ContextPickerAction {
+pub(crate) enum ContextPickerAction {
    AddSelections,
 }

@@ -227,7 +228,7 @@ impl ContextPicker {
    }

    fn build_menu(&mut self, window: &mut Window, cx: &mut Context<Self>) -> Entity<ContextMenu> {
-        let context_picker = cx.entity().clone();
+        let context_picker = cx.entity();

        let menu = ContextMenu::build(window, cx, move |menu, _window, cx| {
            let recent = self.recent_entries(cx);
@@ -531,7 +532,7 @@ impl ContextPicker {
            return vec![];
        };

-        recent_context_picker_entries(
+        recent_context_picker_entries_with_store(
            context_store,
            self.thread_store.clone(),
            self.text_thread_store.clone(),
@@ -585,7 +586,8 @@ impl Render for ContextPicker {
            })
    }
 }
-enum RecentEntry {
+
+pub(crate) enum RecentEntry {
    File {
        project_path: ProjectPath,
        path_prefix: Arc<str>,
@@ -593,7 +595,7 @@ enum RecentEntry {
    Thread(ThreadContextEntry),
 }

-fn available_context_picker_entries(
+pub(crate) fn available_context_picker_entries(
    prompt_store: &Option<Entity<PromptStore>>,
    thread_store: &Option<WeakEntity<ThreadStore>>,
    workspace: &Entity<Workspace>,
@@ -630,24 +632,56 @@ fn available_context_picker_entries(
    entries
 }

-fn recent_context_picker_entries(
+fn recent_context_picker_entries_with_store(
    context_store: Entity<ContextStore>,
    thread_store: Option<WeakEntity<ThreadStore>>,
    text_thread_store: Option<WeakEntity<TextThreadStore>>,
    workspace: Entity<Workspace>,
    exclude_path: Option<ProjectPath>,
    cx: &App,
+) -> Vec<RecentEntry> {
+    let project = workspace.read(cx).project();
+
+    let mut exclude_paths = context_store.read(cx).file_paths(cx);
+    exclude_paths.extend(exclude_path);
+
+    let exclude_paths = exclude_paths
+        .into_iter()
+        .filter_map(|project_path| project.read(cx).absolute_path(&project_path, cx))
+        .collect();
+
+    let exclude_threads = context_store.read(cx).thread_ids();
+
+    recent_context_picker_entries(
+        thread_store,
+        text_thread_store,
+        workspace,
+        &exclude_paths,
+        exclude_threads,
+        cx,
+    )
+}
+
+pub(crate) fn recent_context_picker_entries(
+    thread_store: Option<WeakEntity<ThreadStore>>,
+    text_thread_store: Option<WeakEntity<TextThreadStore>>,
+    workspace: Entity<Workspace>,
+    exclude_paths: &HashSet<PathBuf>,
+    exclude_threads: &HashSet<ThreadId>,
+    cx: &App,
 ) -> Vec<RecentEntry> {
    let mut recent = Vec::with_capacity(6);
-    let mut current_files = context_store.read(cx).file_paths(cx);
-    current_files.extend(exclude_path);
    let workspace = workspace.read(cx);
    let project = workspace.project().read(cx);

    recent.extend(
        workspace
            .recent_navigation_history_iter(cx)
-            .filter(|(path, _)| !current_files.contains(path))
+            .filter(|(_, abs_path)| {
+                abs_path
+                    .as_ref()
+                    .map_or(true, |path| !exclude_paths.contains(path.as_path()))
+            })
            .take(4)
            .filter_map(|(project_path, _)| {
                project
@@ -659,8 +693,6 @@ fn recent_context_picker_entries(
            }),
    );

-    let current_threads = context_store.read(cx).thread_ids();
-
    let active_thread_id = workspace
        .panel::<AgentPanel>(cx)
        .and_then(|panel| Some(panel.read(cx).active_thread(cx)?.read(cx).id()));
@@ -672,7 +704,7 @@ fn recent_context_picker_entries(
        let mut threads = unordered_thread_entries(thread_store, text_thread_store, cx)
            .filter(|(_, thread)| match thread {
                ThreadContextEntry::Thread { id, .. } => {
-                    Some(id) != active_thread_id && !current_threads.contains(id)
+                    Some(id) != active_thread_id && !exclude_threads.contains(id)
                }
                ThreadContextEntry::Context { .. } => true,
            })
@@ -710,7 +742,7 @@ fn add_selections_as_context(
    })
 }

-fn selection_ranges(
+pub(crate) fn selection_ranges(
    workspace: &Entity<Workspace>,
    cx: &mut App,
 ) -> Vec<(Entity<Buffer>, Range<text::Anchor>)> {
@@ -805,42 +837,9 @@ fn render_fold_icon_button(
 ) -> Arc<dyn Send + Sync + Fn(FoldId, Range<Anchor>, &mut App) -> AnyElement> {
    Arc::new({
        move |fold_id, fold_range, cx| {
-            let is_in_text_selection = editor.upgrade().is_some_and(|editor| {
-                editor.update(cx, |editor, cx| {
-                    let snapshot = editor
-                        .buffer()
-                        .update(cx, |multi_buffer, cx| multi_buffer.snapshot(cx));
-
-                    let is_in_pending_selection = || {
-                        editor
-                            .selections
-                            .pending
-                            .as_ref()
-                            .is_some_and(|pending_selection| {
-                                pending_selection
-                                    .selection
-                                    .range()
-                                    .includes(&fold_range, &snapshot)
-                            })
-                    };
-
-                    let mut is_in_complete_selection = || {
-                        editor
-                            .selections
-                            .disjoint_in_range::<usize>(fold_range.clone(), cx)
-                            .into_iter()
-                            .any(|selection| {
-                                // This is needed to cover a corner case, if we just check for an existing
-                                // selection in the fold range, having a cursor at the start of the fold
-                                // marks it as selected. Non-empty selections don't cause this.
-                                let length = selection.end - selection.start;
-                                length > 0
-                            })
-                    };
-
-                    is_in_pending_selection() || is_in_complete_selection()
-                })
-            });
+            let is_in_text_selection = editor
+                .update(cx, |editor, cx| editor.is_range_selected(&fold_range, cx))
+                .unwrap_or_default();

            ButtonLike::new(fold_id)
                .style(ButtonStyle::Filled)
--- a/crates/agent_ui/src/context_picker/completion_provider.rs
+++ b/crates/agent_ui/src/context_picker/completion_provider.rs
@@ -35,7 +35,7 @@ use super::symbol_context_picker::search_symbols;
 use super::thread_context_picker::{ThreadContextEntry, ThreadMatch, search_threads};
 use super::{
    ContextPickerAction, ContextPickerEntry, ContextPickerMode, MentionLink, RecentEntry,
-    available_context_picker_entries, recent_context_picker_entries, selection_ranges,
+    available_context_picker_entries, recent_context_picker_entries_with_store, selection_ranges,
 };
 use crate::message_editor::ContextCreasesAddon;

@@ -787,7 +787,7 @@ impl CompletionProvider for ContextPickerCompletionProvider {
            .and_then(|b| b.read(cx).file())
            .map(|file| ProjectPath::from_file(file.as_ref(), cx));

-        let recent_entries = recent_context_picker_entries(
+        let recent_entries = recent_context_picker_entries_with_store(
            context_store.clone(),
            thread_store.clone(),
            text_thread_store.clone(),
--- a/crates/agent_ui/src/inline_assistant.rs
+++ b/crates/agent_ui/src/inline_assistant.rs
@@ -72,7 +72,7 @@ pub fn init(
        let Some(window) = window else {
            return;
        };
-        let workspace = cx.entity().clone();
+        let workspace = cx.entity();
        InlineAssistant::update_global(cx, |inline_assistant, cx| {
            inline_assistant.register_workspace(&workspace, window, cx)
        });
--- a/crates/agent_ui/src/language_model_selector.rs
+++ b/crates/agent_ui/src/language_model_selector.rs
@@ -1,5 +1,6 @@
 use std::{cmp::Reverse, sync::Arc};

+use cloud_llm_client::Plan;
 use collections::{HashSet, IndexMap};
 use feature_flags::ZedProFeatureFlag;
 use fuzzy::{StringMatch, StringMatchCandidate, match_strings};
@@ -10,7 +11,6 @@ use language_model::{
 };
 use ordered_float::OrderedFloat;
 use picker::{Picker, PickerDelegate};
-use proto::Plan;
 use ui::{ListItem, ListItemSpacing, prelude::*};

 const TRY_ZED_PRO_URL: &str = "https://zed.dev/pro";
@@ -536,7 +536,7 @@ impl PickerDelegate for LanguageModelPickerDelegate {
    ) -> Option<gpui::AnyElement> {
        use feature_flags::FeatureFlagAppExt;

-        let plan = proto::Plan::ZedPro;
+        let plan = Plan::ZedPro;

        Some(
            h_flex()
@@ -557,7 +557,7 @@ impl PickerDelegate for LanguageModelPickerDelegate {
                                window
                                    .dispatch_action(Box::new(zed_actions::OpenAccountSettings), cx)
                            }),
-                        Plan::Free | Plan::ZedProTrial => Button::new(
+                        Plan::ZedFree | Plan::ZedProTrial => Button::new(
                            "try-pro",
                            if plan == Plan::ZedProTrial {
                                "Upgrade to Pro"
--- a/crates/agent_ui/src/message_editor.rs
+++ b/crates/agent_ui/src/message_editor.rs
@@ -6,7 +6,7 @@ use crate::agent_diff::AgentDiffThread;
 use crate::agent_model_selector::AgentModelSelector;
 use crate::tool_compatibility::{IncompatibleToolsState, IncompatibleToolsTooltip};
 use crate::ui::{
-    MaxModeTooltip,
+    BurnModeTooltip,
    preview::{AgentPreview, UsageCallout},
 };
 use agent::history_store::HistoryStore;
@@ -14,7 +14,7 @@ use agent::{
    context::{AgentContextKey, ContextLoadResult, load_context},
    context_store::ContextStoreEvent,
 };
-use agent_settings::{AgentSettings, CompletionMode};
+use agent_settings::{AgentProfileId, AgentSettings, CompletionMode};
 use ai_onboarding::ApiKeysWithProviders;
 use buffer_diff::BufferDiff;
 use cloud_llm_client::CompletionIntent;
@@ -55,7 +55,7 @@ use zed_actions::agent::ToggleModelSelector;

 use crate::context_picker::{ContextPicker, ContextPickerCompletionProvider, crease_for_mention};
 use crate::context_strip::{ContextStrip, ContextStripEvent, SuggestContextKind};
-use crate::profile_selector::ProfileSelector;
+use crate::profile_selector::{ProfileProvider, ProfileSelector};
 use crate::{
    ActiveThread, AgentDiffPane, ChatWithFollow, ExpandMessageEditor, Follow, KeepAll,
    ModelUsageContext, NewThread, OpenAgentDiff, RejectAll, RemoveAllContext, ToggleBurnMode,
@@ -152,6 +152,24 @@ pub(crate) fn create_editor(
    editor
 }

+impl ProfileProvider for Entity<Thread> {
+    fn profiles_supported(&self, cx: &App) -> bool {
+        self.read(cx)
+            .configured_model()
+            .map_or(false, |model| model.model.supports_tools())
+    }
+
+    fn profile_id(&self, cx: &App) -> AgentProfileId {
+        self.read(cx).profile().id().clone()
+    }
+
+    fn set_profile(&self, profile_id: AgentProfileId, cx: &mut App) {
+        self.update(cx, |this, cx| {
+            this.set_profile(profile_id, cx);
+        });
+    }
+}
+
 impl MessageEditor {
    pub fn new(
        fs: Arc<dyn Fs>,
@@ -221,8 +239,9 @@ impl MessageEditor {
            )
        });

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

        Self {
            editor: editor.clone(),
@@ -605,7 +624,7 @@ impl MessageEditor {
                    this.toggle_burn_mode(&ToggleBurnMode, window, cx);
                }))
                .tooltip(move |_window, cx| {
-                    cx.new(|_| MaxModeTooltip::new().selected(burn_mode_enabled))
+                    cx.new(|_| BurnModeTooltip::new().selected(burn_mode_enabled))
                        .into()
                })
                .into_any_element(),
--- a/crates/agent_ui/src/profile_selector.rs
+++ b/crates/agent_ui/src/profile_selector.rs
@@ -1,12 +1,8 @@
 use crate::{ManageProfiles, ToggleProfileSelector};
-use agent::{
-    Thread,
-    agent_profile::{AgentProfile, AvailableProfiles},
-};
+use agent::agent_profile::{AgentProfile, AvailableProfiles};
 use agent_settings::{AgentDockPosition, AgentProfileId, AgentSettings, builtin_profiles};
 use fs::Fs;
-use gpui::{Action, Empty, Entity, FocusHandle, Subscription, prelude::*};
-use language_model::LanguageModelRegistry;
+use gpui::{Action, Entity, FocusHandle, Subscription, prelude::*};
 use settings::{Settings as _, SettingsStore, update_settings_file};
 use std::sync::Arc;
 use ui::{
@@ -14,10 +10,22 @@ use ui::{
    prelude::*,
 };

+/// Trait for types that can provide and manage agent profiles
+pub trait ProfileProvider {
+    /// Get the current profile ID
+    fn profile_id(&self, cx: &App) -> AgentProfileId;
+
+    /// Set the profile ID
+    fn set_profile(&self, profile_id: AgentProfileId, cx: &mut App);
+
+    /// Check if profiles are supported in the current context (e.g. if the model that is selected has tool support)
+    fn profiles_supported(&self, cx: &App) -> bool;
+}
+
 pub struct ProfileSelector {
    profiles: AvailableProfiles,
    fs: Arc<dyn Fs>,
-    thread: Entity<Thread>,
+    provider: Arc<dyn ProfileProvider>,
    menu_handle: PopoverMenuHandle<ContextMenu>,
    focus_handle: FocusHandle,
    _subscriptions: Vec<Subscription>,
@@ -26,7 +34,7 @@ pub struct ProfileSelector {
 impl ProfileSelector {
    pub fn new(
        fs: Arc<dyn Fs>,
-        thread: Entity<Thread>,
+        provider: Arc<dyn ProfileProvider>,
        focus_handle: FocusHandle,
        cx: &mut Context<Self>,
    ) -> Self {
@@ -37,7 +45,7 @@ impl ProfileSelector {
        Self {
            profiles: AgentProfile::available_profiles(cx),
            fs,
-            thread,
+            provider,
            menu_handle: PopoverMenuHandle::default(),
            focus_handle,
            _subscriptions: vec![settings_subscription],
@@ -113,10 +121,10 @@ impl ProfileSelector {
            builtin_profiles::MINIMAL => Some("Chat about anything with no tools."),
            _ => None,
        };
-        let thread_profile_id = self.thread.read(cx).profile().id();
+        let thread_profile_id = self.provider.profile_id(cx);

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

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

        entry.handler({
            let fs = self.fs.clone();
-            let thread = self.thread.clone();
+            let provider = self.provider.clone();
            let profile_id = profile_id.clone();
            move |_window, cx| {
                update_settings_file::<AgentSettings>(fs.clone(), cx, {
@@ -138,9 +146,7 @@ impl ProfileSelector {
                    }
                });

-                thread.update(cx, |this, cx| {
-                    this.set_profile(profile_id.clone(), cx);
-                });
+                provider.set_profile(profile_id.clone(), cx);
            }
        })
    }
@@ -149,23 +155,15 @@ impl ProfileSelector {
 impl Render for ProfileSelector {
    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
        let settings = AgentSettings::get_global(cx);
-        let profile_id = self.thread.read(cx).profile().id();
-        let profile = settings.profiles.get(profile_id);
+        let profile_id = self.provider.profile_id(cx);
+        let profile = settings.profiles.get(&profile_id);

        let selected_profile = profile
            .map(|profile| profile.name.clone())
            .unwrap_or_else(|| "Unknown".into());

-        let configured_model = self.thread.read(cx).configured_model().or_else(|| {
-            let model_registry = LanguageModelRegistry::read_global(cx);
-            model_registry.default_model()
-        });
-        let Some(configured_model) = configured_model else {
-            return Empty.into_any_element();
-        };
-
-        if configured_model.model.supports_tools() {
-            let this = cx.entity().clone();
+        if self.provider.profiles_supported(cx) {
+            let this = cx.entity();
            let focus_handle = self.focus_handle.clone();
            let trigger_button = Button::new("profile-selector-model", selected_profile)
                .label_size(LabelSize::Small)
--- a/crates/agent_ui/src/slash_command_settings.rs
+++ b/crates/agent_ui/src/slash_command_settings.rs
@@ -7,22 +7,11 @@ use settings::{Settings, SettingsSources};
 /// Settings for slash commands.
 #[derive(Deserialize, Serialize, Debug, Default, Clone, JsonSchema)]
 pub struct SlashCommandSettings {
-    /// Settings for the `/docs` slash command.
-    #[serde(default)]
-    pub docs: DocsCommandSettings,
    /// Settings for the `/cargo-workspace` slash command.
    #[serde(default)]
    pub cargo_workspace: CargoWorkspaceCommandSettings,
 }

-/// Settings for the `/docs` slash command.
-#[derive(Deserialize, Serialize, Debug, Default, Clone, JsonSchema)]
-pub struct DocsCommandSettings {
-    /// Whether `/docs` is enabled.
-    #[serde(default)]
-    pub enabled: bool,
-}
-
 /// Settings for the `/cargo-workspace` slash command.
 #[derive(Deserialize, Serialize, Debug, Default, Clone, JsonSchema)]
 pub struct CargoWorkspaceCommandSettings {
--- a/crates/agent_ui/src/text_thread_editor.rs
+++ b/crates/agent_ui/src/text_thread_editor.rs
@@ -1,14 +1,11 @@
 use crate::{
-    burn_mode_tooltip::BurnModeTooltip,
    language_model_selector::{LanguageModelSelector, language_model_selector},
+    ui::BurnModeTooltip,
 };
 use agent_settings::{AgentSettings, CompletionMode};
 use anyhow::Result;
 use assistant_slash_command::{SlashCommand, SlashCommandOutputSection, SlashCommandWorkingSet};
-use assistant_slash_commands::{
-    DefaultSlashCommand, DocsSlashCommand, DocsSlashCommandArgs, FileSlashCommand,
-    selections_creases,
-};
+use assistant_slash_commands::{DefaultSlashCommand, FileSlashCommand, selections_creases};
 use client::{proto, zed_urls};
 use collections::{BTreeSet, HashMap, HashSet, hash_map};
 use editor::{
@@ -30,7 +27,6 @@ use gpui::{
    StatefulInteractiveElement, Styled, Subscription, Task, Transformation, WeakEntity, actions,
    div, img, percentage, point, prelude::*, pulsating_between, size,
 };
-use indexed_docs::IndexedDocsStore;
 use language::{
    BufferSnapshot, LspAdapterDelegate, ToOffset,
    language_settings::{SoftWrap, all_language_settings},
@@ -77,7 +73,7 @@ use crate::{slash_command::SlashCommandCompletionProvider, slash_command_picker}
 use assistant_context::{
    AssistantContext, CacheStatus, Content, ContextEvent, ContextId, InvokedSlashCommandId,
    InvokedSlashCommandStatus, Message, MessageId, MessageMetadata, MessageStatus,
-    ParsedSlashCommand, PendingSlashCommandStatus, ThoughtProcessOutputSection,
+    PendingSlashCommandStatus, ThoughtProcessOutputSection,
 };

 actions!(
@@ -701,19 +697,7 @@ impl TextThreadEditor {
                                }
                            };
                            let render_trailer = {
-                                let command = command.clone();
-                                move |row, _unfold, _window: &mut Window, cx: &mut App| {
-                                    // TODO: In the future we should investigate how we can expose
-                                    // this as a hook on the `SlashCommand` trait so that we don't
-                                    // need to special-case it here.
-                                    if command.name == DocsSlashCommand::NAME {
-                                        return render_docs_slash_command_trailer(
-                                            row,
-                                            command.clone(),
-                                            cx,
-                                        );
-                                    }
-
+                                move |_row, _unfold, _window: &mut Window, _cx: &mut App| {
                                    Empty.into_any()
                                }
                            };
@@ -2398,70 +2382,6 @@ fn render_pending_slash_command_gutter_decoration(
    icon.into_any_element()
 }

-fn render_docs_slash_command_trailer(
-    row: MultiBufferRow,
-    command: ParsedSlashCommand,
-    cx: &mut App,
-) -> AnyElement {
-    if command.arguments.is_empty() {
-        return Empty.into_any();
-    }
-    let args = DocsSlashCommandArgs::parse(&command.arguments);
-
-    let Some(store) = args
-        .provider()
-        .and_then(|provider| IndexedDocsStore::try_global(provider, cx).ok())
-    else {
-        return Empty.into_any();
-    };
-
-    let Some(package) = args.package() else {
-        return Empty.into_any();
-    };
-
-    let mut children = Vec::new();
-
-    if store.is_indexing(&package) {
-        children.push(
-            div()
-                .id(("crates-being-indexed", row.0))
-                .child(Icon::new(IconName::ArrowCircle).with_animation(
-                    "arrow-circle",
-                    Animation::new(Duration::from_secs(4)).repeat(),
-                    |icon, delta| icon.transform(Transformation::rotate(percentage(delta))),
-                ))
-                .tooltip({
-                    let package = package.clone();
-                    Tooltip::text(format!("Indexing {package}…"))
-                })
-                .into_any_element(),
-        );
-    }
-
-    if let Some(latest_error) = store.latest_error_for_package(&package) {
-        children.push(
-            div()
-                .id(("latest-error", row.0))
-                .child(
-                    Icon::new(IconName::Warning)
-                        .size(IconSize::Small)
-                        .color(Color::Warning),
-                )
-                .tooltip(Tooltip::text(format!("Failed to index: {latest_error}")))
-                .into_any_element(),
-        )
-    }
-
-    let is_indexing = store.is_indexing(&package);
-    let latest_error = store.latest_error_for_package(&package);
-
-    if !is_indexing && latest_error.is_none() {
-        return Empty.into_any();
-    }
-
-    h_flex().gap_2().children(children).into_any_element()
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize)]
 struct CopyMetadata {
    creases: Vec<SelectedCreaseMetadata>,
--- a/crates/agent_ui/src/ui.rs
+++ b/crates/agent_ui/src/ui.rs
@@ -2,7 +2,7 @@ mod agent_notification;
 mod burn_mode_tooltip;
 mod context_pill;
 mod end_trial_upsell;
-mod new_thread_button;
+// mod new_thread_button;
 mod onboarding_modal;
 pub mod preview;

@@ -10,5 +10,5 @@ pub use agent_notification::*;
 pub use burn_mode_tooltip::*;
 pub use context_pill::*;
 pub use end_trial_upsell::*;
-pub use new_thread_button::*;
+// pub use new_thread_button::*;
 pub use onboarding_modal::*;
--- a/crates/agent_ui/src/ui/burn_mode_tooltip.rs
+++ b/crates/agent_ui/src/ui/burn_mode_tooltip.rs
@@ -2,11 +2,11 @@ use crate::ToggleBurnMode;
 use gpui::{Context, FontWeight, IntoElement, Render, Window};
 use ui::{KeyBinding, prelude::*, tooltip_container};

-pub struct MaxModeTooltip {
+pub struct BurnModeTooltip {
    selected: bool,
 }

-impl MaxModeTooltip {
+impl BurnModeTooltip {
    pub fn new() -> Self {
        Self { selected: false }
    }
@@ -17,7 +17,7 @@ impl MaxModeTooltip {
    }
 }

-impl Render for MaxModeTooltip {
+impl Render for BurnModeTooltip {
    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
        let (icon, color) = if self.selected {
            (IconName::ZedBurnModeOn, Color::Error)
--- a/crates/agent_ui/src/ui/new_thread_button.rs
+++ b/crates/agent_ui/src/ui/new_thread_button.rs
@@ -11,7 +11,7 @@ pub struct NewThreadButton {
 }

 impl NewThreadButton {
-    pub fn new(id: impl Into<ElementId>, label: impl Into<SharedString>, icon: IconName) -> Self {
+    fn new(id: impl Into<ElementId>, label: impl Into<SharedString>, icon: IconName) -> Self {
        Self {
            id: id.into(),
            label: label.into(),
@@ -21,12 +21,12 @@ impl NewThreadButton {
        }
    }

-    pub fn keybinding(mut self, keybinding: Option<ui::KeyBinding>) -> Self {
+    fn keybinding(mut self, keybinding: Option<ui::KeyBinding>) -> Self {
        self.keybinding = keybinding;
        self
    }

-    pub fn on_click<F>(mut self, handler: F) -> Self
+    fn on_click<F>(mut self, handler: F) -> Self
    where
        F: Fn(&mut Window, &mut App) + 'static,
    {
--- a/crates/assets/src/assets.rs
+++ b/crates/assets/src/assets.rs
@@ -58,9 +58,7 @@ impl Assets {
    pub fn load_test_fonts(&self, cx: &App) {
        cx.text_system()
            .add_fonts(vec![
-                self.load("fonts/plex-mono/ZedPlexMono-Regular.ttf")
-                    .unwrap()
-                    .unwrap(),
+                self.load("fonts/lilex/Lilex-Regular.ttf").unwrap().unwrap(),
            ])
            .unwrap()
    }
--- a/crates/assistant_context/Cargo.toml
+++ b/crates/assistant_context/Cargo.toml
@@ -11,6 +11,9 @@ workspace = true
 [lib]
 path = "src/assistant_context.rs"

+[features]
+test-support = []
+
 [dependencies]
 agent_settings.workspace = true
 anyhow.workspace = true
--- a/crates/assistant_context/src/context_store.rs
+++ b/crates/assistant_context/src/context_store.rs
@@ -138,6 +138,27 @@ impl ContextStore {
        })
    }

+    #[cfg(any(test, feature = "test-support"))]
+    pub fn fake(project: Entity<Project>, cx: &mut Context<Self>) -> Self {
+        Self {
+            contexts: Default::default(),
+            contexts_metadata: Default::default(),
+            context_server_slash_command_ids: Default::default(),
+            host_contexts: Default::default(),
+            fs: project.read(cx).fs().clone(),
+            languages: project.read(cx).languages().clone(),
+            slash_commands: Arc::default(),
+            telemetry: project.read(cx).client().telemetry().clone(),
+            _watch_updates: Task::ready(None),
+            client: project.read(cx).client(),
+            project,
+            project_is_shared: false,
+            client_subscription: None,
+            _project_subscriptions: Default::default(),
+            prompt_builder: Arc::new(PromptBuilder::new(None).unwrap()),
+        }
+    }
+
    async fn handle_advertise_contexts(
        this: Entity<Self>,
        envelope: TypedEnvelope<proto::AdvertiseContexts>,
--- a/crates/assistant_slash_commands/Cargo.toml
+++ b/crates/assistant_slash_commands/Cargo.toml
@@ -27,7 +27,6 @@ globset.workspace = true
 gpui.workspace = true
 html_to_markdown.workspace = true
 http_client.workspace = true
-indexed_docs.workspace = true
 language.workspace = true
 project.workspace = true
 prompt_store.workspace = true
--- a/crates/assistant_slash_commands/src/assistant_slash_commands.rs
+++ b/crates/assistant_slash_commands/src/assistant_slash_commands.rs
@@ -3,7 +3,6 @@ mod context_server_command;
 mod default_command;
 mod delta_command;
 mod diagnostics_command;
-mod docs_command;
 mod fetch_command;
 mod file_command;
 mod now_command;
@@ -18,7 +17,6 @@ pub use crate::context_server_command::*;
 pub use crate::default_command::*;
 pub use crate::delta_command::*;
 pub use crate::diagnostics_command::*;
-pub use crate::docs_command::*;
 pub use crate::fetch_command::*;
 pub use crate::file_command::*;
 pub use crate::now_command::*;
--- a/crates/assistant_slash_commands/src/docs_command.rs
+++ b/crates/assistant_slash_commands/src/docs_command.rs
@@ -1,543 +0,0 @@
-use std::path::Path;
-use std::sync::Arc;
-use std::sync::atomic::AtomicBool;
-use std::time::Duration;
-
-use anyhow::{Context as _, Result, anyhow, bail};
-use assistant_slash_command::{
-    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
-    SlashCommandResult,
-};
-use gpui::{App, BackgroundExecutor, Entity, Task, WeakEntity};
-use indexed_docs::{
-    DocsDotRsProvider, IndexedDocsRegistry, IndexedDocsStore, LocalRustdocProvider, PackageName,
-    ProviderId,
-};
-use language::{BufferSnapshot, LspAdapterDelegate};
-use project::{Project, ProjectPath};
-use ui::prelude::*;
-use util::{ResultExt, maybe};
-use workspace::Workspace;
-
-pub struct DocsSlashCommand;
-
-impl DocsSlashCommand {
-    pub const NAME: &'static str = "docs";
-
-    fn path_to_cargo_toml(project: Entity<Project>, cx: &mut App) -> Option<Arc<Path>> {
-        let worktree = project.read(cx).worktrees(cx).next()?;
-        let worktree = worktree.read(cx);
-        let entry = worktree.entry_for_path("Cargo.toml")?;
-        let path = ProjectPath {
-            worktree_id: worktree.id(),
-            path: entry.path.clone(),
-        };
-        Some(Arc::from(
-            project.read(cx).absolute_path(&path, cx)?.as_path(),
-        ))
-    }
-
-    /// Ensures that the indexed doc providers for Rust are registered.
-    ///
-    /// Ideally we would do this sooner, but we need to wait until we're able to
-    /// access the workspace so we can read the project.
-    fn ensure_rust_doc_providers_are_registered(
-        &self,
-        workspace: Option<WeakEntity<Workspace>>,
-        cx: &mut App,
-    ) {
-        let indexed_docs_registry = IndexedDocsRegistry::global(cx);
-        if indexed_docs_registry
-            .get_provider_store(LocalRustdocProvider::id())
-            .is_none()
-        {
-            let index_provider_deps = maybe!({
-                let workspace = workspace
-                    .as_ref()
-                    .context("no workspace")?
-                    .upgrade()
-                    .context("workspace dropped")?;
-                let project = workspace.read(cx).project().clone();
-                let fs = project.read(cx).fs().clone();
-                let cargo_workspace_root = Self::path_to_cargo_toml(project, cx)
-                    .and_then(|path| path.parent().map(|path| path.to_path_buf()))
-                    .context("no Cargo workspace root found")?;
-
-                anyhow::Ok((fs, cargo_workspace_root))
-            });
-
-            if let Some((fs, cargo_workspace_root)) = index_provider_deps.log_err() {
-                indexed_docs_registry.register_provider(Box::new(LocalRustdocProvider::new(
-                    fs,
-                    cargo_workspace_root,
-                )));
-            }
-        }
-
-        if indexed_docs_registry
-            .get_provider_store(DocsDotRsProvider::id())
-            .is_none()
-        {
-            let http_client = maybe!({
-                let workspace = workspace
-                    .as_ref()
-                    .context("no workspace")?
-                    .upgrade()
-                    .context("workspace was dropped")?;
-                let project = workspace.read(cx).project().clone();
-                anyhow::Ok(project.read(cx).client().http_client())
-            });
-
-            if let Some(http_client) = http_client.log_err() {
-                indexed_docs_registry
-                    .register_provider(Box::new(DocsDotRsProvider::new(http_client)));
-            }
-        }
-    }
-
-    /// Runs just-in-time indexing for a given package, in case the slash command
-    /// is run without any entries existing in the index.
-    fn run_just_in_time_indexing(
-        store: Arc<IndexedDocsStore>,
-        key: String,
-        package: PackageName,
-        executor: BackgroundExecutor,
-    ) -> Task<()> {
-        executor.clone().spawn(async move {
-            let (prefix, needs_full_index) = if let Some((prefix, _)) = key.split_once('*') {
-                // If we have a wildcard in the search, we want to wait until
-                // we've completely finished indexing so we get a full set of
-                // results for the wildcard.
-                (prefix.to_string(), true)
-            } else {
-                (key, false)
-            };
-
-            // If we already have some entries, we assume that we've indexed the package before
-            // and don't need to do it again.
-            let has_any_entries = store
-                .any_with_prefix(prefix.clone())
-                .await
-                .unwrap_or_default();
-            if has_any_entries {
-                return ();
-            };
-
-            let index_task = store.clone().index(package.clone());
-
-            if needs_full_index {
-                _ = index_task.await;
-            } else {
-                loop {
-                    executor.timer(Duration::from_millis(200)).await;
-
-                    if store
-                        .any_with_prefix(prefix.clone())
-                        .await
-                        .unwrap_or_default()
-                        || !store.is_indexing(&package)
-                    {
-                        break;
-                    }
-                }
-            }
-        })
-    }
-}
-
-impl SlashCommand for DocsSlashCommand {
-    fn name(&self) -> String {
-        Self::NAME.into()
-    }
-
-    fn description(&self) -> String {
-        "insert docs".into()
-    }
-
-    fn menu_text(&self) -> String {
-        "Insert Documentation".into()
-    }
-
-    fn requires_argument(&self) -> bool {
-        true
-    }
-
-    fn complete_argument(
-        self: Arc<Self>,
-        arguments: &[String],
-        _cancel: Arc<AtomicBool>,
-        workspace: Option<WeakEntity<Workspace>>,
-        _: &mut Window,
-        cx: &mut App,
-    ) -> Task<Result<Vec<ArgumentCompletion>>> {
-        self.ensure_rust_doc_providers_are_registered(workspace, cx);
-
-        let indexed_docs_registry = IndexedDocsRegistry::global(cx);
-        let args = DocsSlashCommandArgs::parse(arguments);
-        let store = args
-            .provider()
-            .context("no docs provider specified")
-            .and_then(|provider| IndexedDocsStore::try_global(provider, cx));
-        cx.background_spawn(async move {
-            fn build_completions(items: Vec<String>) -> Vec<ArgumentCompletion> {
-                items
-                    .into_iter()
-                    .map(|item| ArgumentCompletion {
-                        label: item.clone().into(),
-                        new_text: item.to_string(),
-                        after_completion: assistant_slash_command::AfterCompletion::Run,
-                        replace_previous_arguments: false,
-                    })
-                    .collect()
-            }
-
-            match args {
-                DocsSlashCommandArgs::NoProvider => {
-                    let providers = indexed_docs_registry.list_providers();
-                    if providers.is_empty() {
-                        return Ok(vec![ArgumentCompletion {
-                            label: "No available docs providers.".into(),
-                            new_text: String::new(),
-                            after_completion: false.into(),
-                            replace_previous_arguments: false,
-                        }]);
-                    }
-
-                    Ok(providers
-                        .into_iter()
-                        .map(|provider| ArgumentCompletion {
-                            label: provider.to_string().into(),
-                            new_text: provider.to_string(),
-                            after_completion: false.into(),
-                            replace_previous_arguments: false,
-                        })
-                        .collect())
-                }
-                DocsSlashCommandArgs::SearchPackageDocs {
-                    provider,
-                    package,
-                    index,
-                } => {
-                    let store = store?;
-
-                    if index {
-                        // We don't need to hold onto this task, as the `IndexedDocsStore` will hold it
-                        // until it completes.
-                        drop(store.clone().index(package.as_str().into()));
-                    }
-
-                    let suggested_packages = store.clone().suggest_packages().await?;
-                    let search_results = store.search(package).await;
-
-                    let mut items = build_completions(search_results);
-                    let workspace_crate_completions = suggested_packages
-                        .into_iter()
-                        .filter(|package_name| {
-                            !items
-                                .iter()
-                                .any(|item| item.label.text() == package_name.as_ref())
-                        })
-                        .map(|package_name| ArgumentCompletion {
-                            label: format!("{package_name} (unindexed)").into(),
-                            new_text: format!("{package_name}"),
-                            after_completion: true.into(),
-                            replace_previous_arguments: false,
-                        })
-                        .collect::<Vec<_>>();
-                    items.extend(workspace_crate_completions);
-
-                    if items.is_empty() {
-                        return Ok(vec![ArgumentCompletion {
-                            label: format!(
-                                "Enter a {package_term} name.",
-                                package_term = package_term(&provider)
-                            )
-                            .into(),
-                            new_text: provider.to_string(),
-                            after_completion: false.into(),
-                            replace_previous_arguments: false,
-                        }]);
-                    }
-
-                    Ok(items)
-                }
-                DocsSlashCommandArgs::SearchItemDocs { item_path, .. } => {
-                    let store = store?;
-                    let items = store.search(item_path).await;
-                    Ok(build_completions(items))
-                }
-            }
-        })
-    }
-
-    fn run(
-        self: Arc<Self>,
-        arguments: &[String],
-        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
-        _context_buffer: BufferSnapshot,
-        _workspace: WeakEntity<Workspace>,
-        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
-        _: &mut Window,
-        cx: &mut App,
-    ) -> Task<SlashCommandResult> {
-        if arguments.is_empty() {
-            return Task::ready(Err(anyhow!("missing an argument")));
-        };
-
-        let args = DocsSlashCommandArgs::parse(arguments);
-        let executor = cx.background_executor().clone();
-        let task = cx.background_spawn({
-            let store = args
-                .provider()
-                .context("no docs provider specified")
-                .and_then(|provider| IndexedDocsStore::try_global(provider, cx));
-            async move {
-                let (provider, key) = match args.clone() {
-                    DocsSlashCommandArgs::NoProvider => bail!("no docs provider specified"),
-                    DocsSlashCommandArgs::SearchPackageDocs {
-                        provider, package, ..
-                    } => (provider, package),
-                    DocsSlashCommandArgs::SearchItemDocs {
-                        provider,
-                        item_path,
-                        ..
-                    } => (provider, item_path),
-                };
-
-                if key.trim().is_empty() {
-                    bail!(
-                        "no {package_term} name provided",
-                        package_term = package_term(&provider)
-                    );
-                }
-
-                let store = store?;
-
-                if let Some(package) = args.package() {
-                    Self::run_just_in_time_indexing(store.clone(), key.clone(), package, executor)
-                        .await;
-                }
-
-                let (text, ranges) = if let Some((prefix, _)) = key.split_once('*') {
-                    let docs = store.load_many_by_prefix(prefix.to_string()).await?;
-
-                    let mut text = String::new();
-                    let mut ranges = Vec::new();
-
-                    for (key, docs) in docs {
-                        let prev_len = text.len();
-
-                        text.push_str(&docs.0);
-                        text.push_str("\n");
-                        ranges.push((key, prev_len..text.len()));
-                        text.push_str("\n");
-                    }
-
-                    (text, ranges)
-                } else {
-                    let item_docs = store.load(key.clone()).await?;
-                    let text = item_docs.to_string();
-                    let range = 0..text.len();
-
-                    (text, vec![(key, range)])
-                };
-
-                anyhow::Ok((provider, text, ranges))
-            }
-        });
-
-        cx.foreground_executor().spawn(async move {
-            let (provider, text, ranges) = task.await?;
-            Ok(SlashCommandOutput {
-                text,
-                sections: ranges
-                    .into_iter()
-                    .map(|(key, range)| SlashCommandOutputSection {
-                        range,
-                        icon: IconName::FileDoc,
-                        label: format!("docs ({provider}): {key}",).into(),
-                        metadata: None,
-                    })
-                    .collect(),
-                run_commands_in_text: false,
-            }
-            .to_event_stream())
-        })
-    }
-}
-
-fn is_item_path_delimiter(char: char) -> bool {
-    !char.is_alphanumeric() && char != '-' && char != '_'
-}
-
-#[derive(Debug, PartialEq, Clone)]
-pub enum DocsSlashCommandArgs {
-    NoProvider,
-    SearchPackageDocs {
-        provider: ProviderId,
-        package: String,
-        index: bool,
-    },
-    SearchItemDocs {
-        provider: ProviderId,
-        package: String,
-        item_path: String,
-    },
-}
-
-impl DocsSlashCommandArgs {
-    pub fn parse(arguments: &[String]) -> Self {
-        let Some(provider) = arguments
-            .get(0)
-            .cloned()
-            .filter(|arg| !arg.trim().is_empty())
-        else {
-            return Self::NoProvider;
-        };
-        let provider = ProviderId(provider.into());
-        let Some(argument) = arguments.get(1) else {
-            return Self::NoProvider;
-        };
-
-        if let Some((package, rest)) = argument.split_once(is_item_path_delimiter) {
-            if rest.trim().is_empty() {
-                Self::SearchPackageDocs {
-                    provider,
-                    package: package.to_owned(),
-                    index: true,
-                }
-            } else {
-                Self::SearchItemDocs {
-                    provider,
-                    package: package.to_owned(),
-                    item_path: argument.to_owned(),
-                }
-            }
-        } else {
-            Self::SearchPackageDocs {
-                provider,
-                package: argument.to_owned(),
-                index: false,
-            }
-        }
-    }
-
-    pub fn provider(&self) -> Option<ProviderId> {
-        match self {
-            Self::NoProvider => None,
-            Self::SearchPackageDocs { provider, .. } | Self::SearchItemDocs { provider, .. } => {
-                Some(provider.clone())
-            }
-        }
-    }
-
-    pub fn package(&self) -> Option<PackageName> {
-        match self {
-            Self::NoProvider => None,
-            Self::SearchPackageDocs { package, .. } | Self::SearchItemDocs { package, .. } => {
-                Some(package.as_str().into())
-            }
-        }
-    }
-}
-
-/// Returns the term used to refer to a package.
-fn package_term(provider: &ProviderId) -> &'static str {
-    if provider == &DocsDotRsProvider::id() || provider == &LocalRustdocProvider::id() {
-        return "crate";
-    }
-
-    "package"
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_parse_docs_slash_command_args() {
-        assert_eq!(
-            DocsSlashCommandArgs::parse(&["".to_string()]),
-            DocsSlashCommandArgs::NoProvider
-        );
-        assert_eq!(
-            DocsSlashCommandArgs::parse(&["rustdoc".to_string()]),
-            DocsSlashCommandArgs::NoProvider
-        );
-
-        assert_eq!(
-            DocsSlashCommandArgs::parse(&["rustdoc".to_string(), "".to_string()]),
-            DocsSlashCommandArgs::SearchPackageDocs {
-                provider: ProviderId("rustdoc".into()),
-                package: "".into(),
-                index: false
-            }
-        );
-        assert_eq!(
-            DocsSlashCommandArgs::parse(&["gleam".to_string(), "".to_string()]),
-            DocsSlashCommandArgs::SearchPackageDocs {
-                provider: ProviderId("gleam".into()),
-                package: "".into(),
-                index: false
-            }
-        );
-
-        assert_eq!(
-            DocsSlashCommandArgs::parse(&["rustdoc".to_string(), "gpui".to_string()]),
-            DocsSlashCommandArgs::SearchPackageDocs {
-                provider: ProviderId("rustdoc".into()),
-                package: "gpui".into(),
-                index: false,
-            }
-        );
-        assert_eq!(
-            DocsSlashCommandArgs::parse(&["gleam".to_string(), "gleam_stdlib".to_string()]),
-            DocsSlashCommandArgs::SearchPackageDocs {
-                provider: ProviderId("gleam".into()),
-                package: "gleam_stdlib".into(),
-                index: false
-            }
-        );
-
-        // Adding an item path delimiter indicates we can start indexing.
-        assert_eq!(
-            DocsSlashCommandArgs::parse(&["rustdoc".to_string(), "gpui:".to_string()]),
-            DocsSlashCommandArgs::SearchPackageDocs {
-                provider: ProviderId("rustdoc".into()),
-                package: "gpui".into(),
-                index: true,
-            }
-        );
-        assert_eq!(
-            DocsSlashCommandArgs::parse(&["gleam".to_string(), "gleam_stdlib/".to_string()]),
-            DocsSlashCommandArgs::SearchPackageDocs {
-                provider: ProviderId("gleam".into()),
-                package: "gleam_stdlib".into(),
-                index: true
-            }
-        );
-
-        assert_eq!(
-            DocsSlashCommandArgs::parse(&[
-                "rustdoc".to_string(),
-                "gpui::foo::bar::Baz".to_string()
-            ]),
-            DocsSlashCommandArgs::SearchItemDocs {
-                provider: ProviderId("rustdoc".into()),
-                package: "gpui".into(),
-                item_path: "gpui::foo::bar::Baz".into()
-            }
-        );
-        assert_eq!(
-            DocsSlashCommandArgs::parse(&[
-                "gleam".to_string(),
-                "gleam_stdlib/gleam/int".to_string()
-            ]),
-            DocsSlashCommandArgs::SearchItemDocs {
-                provider: ProviderId("gleam".into()),
-                package: "gleam_stdlib".into(),
-                item_path: "gleam_stdlib/gleam/int".into()
-            }
-        );
-    }
-}
--- a/crates/assistant_tools/src/edit_agent.rs
+++ b/crates/assistant_tools/src/edit_agent.rs
@@ -65,7 +65,7 @@ pub enum EditAgentOutputEvent {
    ResolvingEditRange(Range<Anchor>),
    UnresolvedEditRange,
    AmbiguousEditRange(Vec<Range<usize>>),
-    Edited,
+    Edited(Range<Anchor>),
 }

 #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
@@ -178,7 +178,9 @@ impl EditAgent {
                )
            });
            output_events_tx
-                .unbounded_send(EditAgentOutputEvent::Edited)
+                .unbounded_send(EditAgentOutputEvent::Edited(
+                    language::Anchor::MIN..language::Anchor::MAX,
+                ))
                .ok();
        })?;

@@ -200,7 +202,9 @@ impl EditAgent {
                        });
                    })?;
                    output_events_tx
-                        .unbounded_send(EditAgentOutputEvent::Edited)
+                        .unbounded_send(EditAgentOutputEvent::Edited(
+                            language::Anchor::MIN..language::Anchor::MAX,
+                        ))
                        .ok();
                }
            }
@@ -336,8 +340,8 @@ impl EditAgent {
                // Edit the buffer and report edits to the action log as part of the
                // same effect cycle, otherwise the edit will be reported as if the
                // user made it.
-                cx.update(|cx| {
-                    let max_edit_end = buffer.update(cx, |buffer, cx| {
+                let (min_edit_start, max_edit_end) = cx.update(|cx| {
+                    let (min_edit_start, max_edit_end) = buffer.update(cx, |buffer, cx| {
                        buffer.edit(edits.iter().cloned(), None, cx);
                        let max_edit_end = buffer
                            .summaries_for_anchors::<Point, _>(
@@ -345,7 +349,16 @@ impl EditAgent {
                            )
                            .max()
                            .unwrap();
-                        buffer.anchor_before(max_edit_end)
+                        let min_edit_start = buffer
+                            .summaries_for_anchors::<Point, _>(
+                                edits.iter().map(|(range, _)| &range.start),
+                            )
+                            .min()
+                            .unwrap();
+                        (
+                            buffer.anchor_after(min_edit_start),
+                            buffer.anchor_before(max_edit_end),
+                        )
                    });
                    self.action_log
                        .update(cx, |log, cx| log.buffer_edited(buffer.clone(), cx));
@@ -358,9 +371,10 @@ impl EditAgent {
                            cx,
                        );
                    });
+                    (min_edit_start, max_edit_end)
                })?;
                output_events
-                    .unbounded_send(EditAgentOutputEvent::Edited)
+                    .unbounded_send(EditAgentOutputEvent::Edited(min_edit_start..max_edit_end))
                    .ok();
            }

@@ -755,6 +769,7 @@ mod tests {
    use gpui::{AppContext, TestAppContext};
    use indoc::indoc;
    use language_model::fake_provider::FakeLanguageModel;
+    use pretty_assertions::assert_matches;
    use project::{AgentLocation, Project};
    use rand::prelude::*;
    use rand::rngs::StdRng;
@@ -992,7 +1007,10 @@ mod tests {

        model.send_last_completion_stream_text_chunk("<new_text>abX");
        cx.run_until_parked();
-        assert_eq!(drain_events(&mut events), [EditAgentOutputEvent::Edited]);
+        assert_matches!(
+            drain_events(&mut events).as_slice(),
+            [EditAgentOutputEvent::Edited(_)]
+        );
        assert_eq!(
            buffer.read_with(cx, |buffer, _| buffer.snapshot().text()),
            "abXc\ndef\nghi\njkl"
@@ -1007,7 +1025,10 @@ mod tests {

        model.send_last_completion_stream_text_chunk("cY");
        cx.run_until_parked();
-        assert_eq!(drain_events(&mut events), [EditAgentOutputEvent::Edited]);
+        assert_matches!(
+            drain_events(&mut events).as_slice(),
+            [EditAgentOutputEvent::Edited { .. }]
+        );
        assert_eq!(
            buffer.read_with(cx, |buffer, _| buffer.snapshot().text()),
            "abXcY\ndef\nghi\njkl"
@@ -1118,9 +1139,9 @@ mod tests {

        model.send_last_completion_stream_text_chunk("GHI</new_text>");
        cx.run_until_parked();
-        assert_eq!(
-            drain_events(&mut events),
-            vec![EditAgentOutputEvent::Edited]
+        assert_matches!(
+            drain_events(&mut events).as_slice(),
+            [EditAgentOutputEvent::Edited { .. }]
        );
        assert_eq!(
            buffer.read_with(cx, |buffer, _| buffer.snapshot().text()),
@@ -1165,9 +1186,9 @@ mod tests {
        );

        cx.run_until_parked();
-        assert_eq!(
-            drain_events(&mut events),
-            vec![EditAgentOutputEvent::Edited]
+        assert_matches!(
+            drain_events(&mut events).as_slice(),
+            [EditAgentOutputEvent::Edited(_)]
        );
        assert_eq!(
            buffer.read_with(cx, |buffer, _| buffer.snapshot().text()),
@@ -1183,9 +1204,9 @@ mod tests {

        chunks_tx.unbounded_send("```\njkl\n").unwrap();
        cx.run_until_parked();
-        assert_eq!(
-            drain_events(&mut events),
-            vec![EditAgentOutputEvent::Edited]
+        assert_matches!(
+            drain_events(&mut events).as_slice(),
+            [EditAgentOutputEvent::Edited { .. }]
        );
        assert_eq!(
            buffer.read_with(cx, |buffer, _| buffer.snapshot().text()),
@@ -1201,9 +1222,9 @@ mod tests {

        chunks_tx.unbounded_send("mno\n").unwrap();
        cx.run_until_parked();
-        assert_eq!(
-            drain_events(&mut events),
-            vec![EditAgentOutputEvent::Edited]
+        assert_matches!(
+            drain_events(&mut events).as_slice(),
+            [EditAgentOutputEvent::Edited { .. }]
        );
        assert_eq!(
            buffer.read_with(cx, |buffer, _| buffer.snapshot().text()),
@@ -1219,9 +1240,9 @@ mod tests {

        chunks_tx.unbounded_send("pqr\n```").unwrap();
        cx.run_until_parked();
-        assert_eq!(
-            drain_events(&mut events),
-            vec![EditAgentOutputEvent::Edited]
+        assert_matches!(
+            drain_events(&mut events).as_slice(),
+            [EditAgentOutputEvent::Edited(_)],
        );
        assert_eq!(
            buffer.read_with(cx, |buffer, _| buffer.snapshot().text()),
--- a/crates/assistant_tools/src/edit_file_tool.rs
+++ b/crates/assistant_tools/src/edit_file_tool.rs
@@ -307,7 +307,7 @@ impl Tool for EditFileTool {
            let mut ambiguous_ranges = Vec::new();
            while let Some(event) = events.next().await {
                match event {
-                    EditAgentOutputEvent::Edited => {
+                    EditAgentOutputEvent::Edited { .. } => {
                        if let Some(card) = card_clone.as_ref() {
                            card.update(cx, |card, cx| card.update_diff(cx))?;
                        }
--- a/crates/audio/Cargo.toml
+++ b/crates/audio/Cargo.toml
@@ -18,6 +18,6 @@ collections.workspace = true
 derive_more.workspace = true
 gpui.workspace = true
 parking_lot.workspace = true
-rodio = { version = "0.21.1", default-features = false, features = ["wav", "playback", "tracing"] }
+rodio = { workspace = true, features = [ "wav", "playback", "tracing" ] }
 util.workspace = true
 workspace-hack.workspace = true
--- a/crates/auto_update/src/auto_update.rs
+++ b/crates/auto_update/src/auto_update.rs
@@ -59,16 +59,9 @@ pub enum VersionCheckType {
 pub enum AutoUpdateStatus {
    Idle,
    Checking,
-    Downloading {
-        version: VersionCheckType,
-    },
-    Installing {
-        version: VersionCheckType,
-    },
-    Updated {
-        binary_path: PathBuf,
-        version: VersionCheckType,
-    },
+    Downloading { version: VersionCheckType },
+    Installing { version: VersionCheckType },
+    Updated { version: VersionCheckType },
    Errored,
 }

@@ -83,6 +76,7 @@ pub struct AutoUpdater {
    current_version: SemanticVersion,
    http_client: Arc<HttpClientWithUrl>,
    pending_poll: Option<Task<Option<()>>>,
+    quit_subscription: Option<gpui::Subscription>,
 }

 #[derive(Deserialize, Clone, Debug)]
@@ -164,7 +158,7 @@ pub fn init(http_client: Arc<HttpClientWithUrl>, cx: &mut App) {
    AutoUpdateSetting::register(cx);

    cx.observe_new(|workspace: &mut Workspace, _window, _cx| {
-        workspace.register_action(|_, action: &Check, window, cx| check(action, window, cx));
+        workspace.register_action(|_, action, window, cx| check(action, window, cx));

        workspace.register_action(|_, action, _, cx| {
            view_release_notes(action, cx);
@@ -174,7 +168,7 @@ pub fn init(http_client: Arc<HttpClientWithUrl>, cx: &mut App) {

    let version = release_channel::AppVersion::global(cx);
    let auto_updater = cx.new(|cx| {
-        let updater = AutoUpdater::new(version, http_client);
+        let updater = AutoUpdater::new(version, http_client, cx);

        let poll_for_updates = ReleaseChannel::try_global(cx)
            .map(|channel| channel.poll_for_updates())
@@ -321,12 +315,34 @@ impl AutoUpdater {
        cx.default_global::<GlobalAutoUpdate>().0.clone()
    }

-    fn new(current_version: SemanticVersion, http_client: Arc<HttpClientWithUrl>) -> Self {
+    fn new(
+        current_version: SemanticVersion,
+        http_client: Arc<HttpClientWithUrl>,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        // On windows, executable files cannot be overwritten while they are
+        // running, so we must wait to overwrite the application until quitting
+        // or restarting. When quitting the app, we spawn the auto update helper
+        // to finish the auto update process after Zed exits. When restarting
+        // the app after an update, we use `set_restart_path` to run the auto
+        // update helper instead of the app, so that it can overwrite the app
+        // and then spawn the new binary.
+        let quit_subscription = Some(cx.on_app_quit(|_, _| async move {
+            #[cfg(target_os = "windows")]
+            finalize_auto_update_on_quit();
+        }));
+
+        cx.on_app_restart(|this, _| {
+            this.quit_subscription.take();
+        })
+        .detach();
+
        Self {
            status: AutoUpdateStatus::Idle,
            current_version,
            http_client,
            pending_poll: None,
+            quit_subscription,
        }
    }

@@ -536,6 +552,8 @@ impl AutoUpdater {
                )
            })?;

+        Self::check_dependencies()?;
+
        this.update(&mut cx, |this, cx| {
            this.status = AutoUpdateStatus::Checking;
            cx.notify();
@@ -582,13 +600,15 @@ impl AutoUpdater {
            cx.notify();
        })?;

-        let binary_path = Self::binary_path(installer_dir, target_path, &cx).await?;
+        let new_binary_path = Self::install_release(installer_dir, target_path, &cx).await?;
+        if let Some(new_binary_path) = new_binary_path {
+            cx.update(|cx| cx.set_restart_path(new_binary_path))?;
+        }

        this.update(&mut cx, |this, cx| {
            this.set_should_show_update_notification(true, cx)
                .detach_and_log_err(cx);
            this.status = AutoUpdateStatus::Updated {
-                binary_path,
                version: newer_version,
            };
            cx.notify();
@@ -639,6 +659,15 @@ impl AutoUpdater {
        }
    }

+    fn check_dependencies() -> Result<()> {
+        #[cfg(not(target_os = "windows"))]
+        anyhow::ensure!(
+            which::which("rsync").is_ok(),
+            "Aborting. Could not find rsync which is required for auto-updates."
+        );
+        Ok(())
+    }
+
    async fn target_path(installer_dir: &InstallerDir) -> Result<PathBuf> {
        let filename = match OS {
            "macos" => anyhow::Ok("Zed.dmg"),
@@ -647,20 +676,14 @@ impl AutoUpdater {
            unsupported_os => anyhow::bail!("not supported: {unsupported_os}"),
        }?;

-        #[cfg(not(target_os = "windows"))]
-        anyhow::ensure!(
-            which::which("rsync").is_ok(),
-            "Aborting. Could not find rsync which is required for auto-updates."
-        );
-
        Ok(installer_dir.path().join(filename))
    }

-    async fn binary_path(
+    async fn install_release(
        installer_dir: InstallerDir,
        target_path: PathBuf,
        cx: &AsyncApp,
-    ) -> Result<PathBuf> {
+    ) -> Result<Option<PathBuf>> {
        match OS {
            "macos" => install_release_macos(&installer_dir, target_path, cx).await,
            "linux" => install_release_linux(&installer_dir, target_path, cx).await,
@@ -801,7 +824,7 @@ async fn install_release_linux(
    temp_dir: &InstallerDir,
    downloaded_tar_gz: PathBuf,
    cx: &AsyncApp,
-) -> Result<PathBuf> {
+) -> Result<Option<PathBuf>> {
    let channel = cx.update(|cx| ReleaseChannel::global(cx).dev_name())?;
    let home_dir = PathBuf::from(env::var("HOME").context("no HOME env var set")?);
    let running_app_path = cx.update(|cx| cx.app_path())??;
@@ -861,14 +884,14 @@ async fn install_release_linux(
        String::from_utf8_lossy(&output.stderr)
    );

-    Ok(to.join(expected_suffix))
+    Ok(Some(to.join(expected_suffix)))
 }

 async fn install_release_macos(
    temp_dir: &InstallerDir,
    downloaded_dmg: PathBuf,
    cx: &AsyncApp,
-) -> Result<PathBuf> {
+) -> Result<Option<PathBuf>> {
    let running_app_path = cx.update(|cx| cx.app_path())??;
    let running_app_filename = running_app_path
        .file_name()
@@ -910,10 +933,10 @@ async fn install_release_macos(
        String::from_utf8_lossy(&output.stderr)
    );

-    Ok(running_app_path)
+    Ok(None)
 }

-async fn install_release_windows(downloaded_installer: PathBuf) -> Result<PathBuf> {
+async fn install_release_windows(downloaded_installer: PathBuf) -> Result<Option<PathBuf>> {
    let output = Command::new(downloaded_installer)
        .arg("/verysilent")
        .arg("/update=true")
@@ -926,29 +949,36 @@ async fn install_release_windows(downloaded_installer: PathBuf) -> Result<PathBu
        "failed to start installer: {:?}",
        String::from_utf8_lossy(&output.stderr)
    );
-    Ok(std::env::current_exe()?)
+    // We return the path to the update helper program, because it will
+    // perform the final steps of the update process, copying the new binary,
+    // deleting the old one, and launching the new binary.
+    let helper_path = std::env::current_exe()?
+        .parent()
+        .context("No parent dir for Zed.exe")?
+        .join("tools\\auto_update_helper.exe");
+    Ok(Some(helper_path))
 }

-pub fn check_pending_installation() -> bool {
+pub fn finalize_auto_update_on_quit() {
    let Some(installer_path) = std::env::current_exe()
        .ok()
        .and_then(|p| p.parent().map(|p| p.join("updates")))
    else {
-        return false;
+        return;
    };

    // The installer will create a flag file after it finishes updating
    let flag_file = installer_path.join("versions.txt");
-    if flag_file.exists() {
-        if let Some(helper) = installer_path
+    if flag_file.exists()
+        && let Some(helper) = installer_path
            .parent()
            .map(|p| p.join("tools\\auto_update_helper.exe"))
-        {
-            let _ = std::process::Command::new(helper).spawn();
-            return true;
-        }
+    {
+        let mut command = std::process::Command::new(helper);
+        command.arg("--launch");
+        command.arg("false");
+        let _ = command.spawn();
    }
-    false
 }

 #[cfg(test)]
@@ -1002,7 +1032,6 @@ mod tests {
        let app_commit_sha = Ok(Some("a".to_string()));
        let installed_version = SemanticVersion::new(1, 0, 0);
        let status = AutoUpdateStatus::Updated {
-            binary_path: PathBuf::new(),
            version: VersionCheckType::Semantic(SemanticVersion::new(1, 0, 1)),
        };
        let fetched_version = SemanticVersion::new(1, 0, 1);
@@ -1024,7 +1053,6 @@ mod tests {
        let app_commit_sha = Ok(Some("a".to_string()));
        let installed_version = SemanticVersion::new(1, 0, 0);
        let status = AutoUpdateStatus::Updated {
-            binary_path: PathBuf::new(),
            version: VersionCheckType::Semantic(SemanticVersion::new(1, 0, 1)),
        };
        let fetched_version = SemanticVersion::new(1, 0, 2);
@@ -1090,7 +1118,6 @@ mod tests {
        let app_commit_sha = Ok(Some("a".to_string()));
        let installed_version = SemanticVersion::new(1, 0, 0);
        let status = AutoUpdateStatus::Updated {
-            binary_path: PathBuf::new(),
            version: VersionCheckType::Sha(AppCommitSha::new("b".to_string())),
        };
        let fetched_sha = "b".to_string();
@@ -1112,7 +1139,6 @@ mod tests {
        let app_commit_sha = Ok(Some("a".to_string()));
        let installed_version = SemanticVersion::new(1, 0, 0);
        let status = AutoUpdateStatus::Updated {
-            binary_path: PathBuf::new(),
            version: VersionCheckType::Sha(AppCommitSha::new("b".to_string())),
        };
        let fetched_sha = "c".to_string();
@@ -1160,7 +1186,6 @@ mod tests {
        let app_commit_sha = Ok(None);
        let installed_version = SemanticVersion::new(1, 0, 0);
        let status = AutoUpdateStatus::Updated {
-            binary_path: PathBuf::new(),
            version: VersionCheckType::Sha(AppCommitSha::new("b".to_string())),
        };
        let fetched_sha = "b".to_string();
@@ -1183,7 +1208,6 @@ mod tests {
        let app_commit_sha = Ok(None);
        let installed_version = SemanticVersion::new(1, 0, 0);
        let status = AutoUpdateStatus::Updated {
-            binary_path: PathBuf::new(),
            version: VersionCheckType::Sha(AppCommitSha::new("b".to_string())),
        };
        let fetched_sha = "c".to_string();
--- a/crates/auto_update_helper/src/auto_update_helper.rs
+++ b/crates/auto_update_helper/src/auto_update_helper.rs
@@ -18,7 +18,7 @@ fn main() {}

 #[cfg(target_os = "windows")]
 mod windows_impl {
-    use std::path::Path;
+    use std::{borrow::Cow, path::Path};

    use super::dialog::create_dialog_window;
    use super::updater::perform_update;
@@ -37,6 +37,11 @@ mod windows_impl {
    pub(crate) const WM_JOB_UPDATED: u32 = WM_USER + 1;
    pub(crate) const WM_TERMINATE: u32 = WM_USER + 2;

+    #[derive(Debug, Default)]
+    struct Args {
+        launch: bool,
+    }
+
    pub(crate) fn run() -> Result<()> {
        let helper_dir = std::env::current_exe()?
            .parent()
@@ -51,8 +56,9 @@ mod windows_impl {
        log::info!("======= Starting Zed update =======");
        let (tx, rx) = std::sync::mpsc::channel();
        let hwnd = create_dialog_window(rx)?.0 as isize;
+        let args = parse_args(std::env::args().skip(1));
        std::thread::spawn(move || {
-            let result = perform_update(app_dir.as_path(), Some(hwnd));
+            let result = perform_update(app_dir.as_path(), Some(hwnd), args.launch);
            tx.send(result).ok();
            unsafe { PostMessageW(Some(HWND(hwnd as _)), WM_TERMINATE, WPARAM(0), LPARAM(0)) }.ok();
        });
@@ -77,6 +83,29 @@ mod windows_impl {
        Ok(())
    }

+    fn parse_args(input: impl IntoIterator<Item = String>) -> Args {
+        let mut args: Args = Args { launch: true };
+
+        let mut input = input.into_iter();
+        if let Some(arg) = input.next() {
+            let launch_arg;
+
+            if arg == "--launch" {
+                launch_arg = input.next().map(Cow::Owned);
+            } else if let Some(rest) = arg.strip_prefix("--launch=") {
+                launch_arg = Some(Cow::Borrowed(rest));
+            } else {
+                launch_arg = None;
+            }
+
+            if launch_arg.as_deref() == Some("false") {
+                args.launch = false;
+            }
+        }
+
+        args
+    }
+
    pub(crate) fn show_error(mut content: String) {
        if content.len() > 600 {
            content.truncate(600);
@@ -91,4 +120,31 @@ mod windows_impl {
            )
        };
    }
+
+    #[cfg(test)]
+    mod tests {
+        use crate::windows_impl::parse_args;
+
+        #[test]
+        fn test_parse_args() {
+            // launch can be specified via two separate arguments
+            assert_eq!(parse_args(["--launch".into(), "true".into()]).launch, true);
+            assert_eq!(
+                parse_args(["--launch".into(), "false".into()]).launch,
+                false
+            );
+
+            // launch can be specified via one single argument
+            assert_eq!(parse_args(["--launch=true".into()]).launch, true);
+            assert_eq!(parse_args(["--launch=false".into()]).launch, false);
+
+            // launch defaults to true on no arguments
+            assert_eq!(parse_args([]).launch, true);
+
+            // launch defaults to true on invalid arguments
+            assert_eq!(parse_args(["--launch".into()]).launch, true);
+            assert_eq!(parse_args(["--launch=".into()]).launch, true);
+            assert_eq!(parse_args(["--launch=invalid".into()]).launch, true);
+        }
+    }
 }
--- a/crates/auto_update_helper/src/dialog.rs
+++ b/crates/auto_update_helper/src/dialog.rs
@@ -72,7 +72,7 @@ pub(crate) fn create_dialog_window(receiver: Receiver<Result<()>>) -> Result<HWN
        let hwnd = CreateWindowExW(
            WS_EX_TOPMOST,
            class_name,
-            windows::core::w!("Zed Editor"),
+            windows::core::w!("Zed"),
            WS_VISIBLE | WS_POPUP | WS_CAPTION,
            rect.right / 2 - width / 2,
            rect.bottom / 2 - height / 2,
@@ -171,7 +171,7 @@ unsafe extern "system" fn wnd_proc(
                &HSTRING::from(font_name),
            );
            let temp = SelectObject(hdc, font.into());
-            let string = HSTRING::from("Zed Editor is updating...");
+            let string = HSTRING::from("Updating Zed...");
            return_if_failed!(TextOutW(hdc, 20, 15, &string).ok());
            return_if_failed!(DeleteObject(temp).ok());

--- a/crates/auto_update_helper/src/updater.rs
+++ b/crates/auto_update_helper/src/updater.rs
@@ -118,7 +118,7 @@ pub(crate) const JOBS: [Job; 2] = [
    },
 ];

-pub(crate) fn perform_update(app_dir: &Path, hwnd: Option<isize>) -> Result<()> {
+pub(crate) fn perform_update(app_dir: &Path, hwnd: Option<isize>, launch: bool) -> Result<()> {
    let hwnd = hwnd.map(|ptr| HWND(ptr as _));

    for job in JOBS.iter() {
@@ -145,9 +145,11 @@ pub(crate) fn perform_update(app_dir: &Path, hwnd: Option<isize>) -> Result<()>
            }
        }
    }
-    let _ = std::process::Command::new(app_dir.join("Zed.exe"))
-        .creation_flags(CREATE_NEW_PROCESS_GROUP.0)
-        .spawn();
+    if launch {
+        let _ = std::process::Command::new(app_dir.join("Zed.exe"))
+            .creation_flags(CREATE_NEW_PROCESS_GROUP.0)
+            .spawn();
+    }
    log::info!("Update completed successfully");
    Ok(())
 }
@@ -159,11 +161,11 @@ mod test {
    #[test]
    fn test_perform_update() {
        let app_dir = std::path::Path::new("C:/");
-        assert!(perform_update(app_dir, None).is_ok());
+        assert!(perform_update(app_dir, None, false).is_ok());

        // Simulate a timeout
        unsafe { std::env::set_var("ZED_AUTO_UPDATE", "err") };
-        let ret = perform_update(app_dir, None);
+        let ret = perform_update(app_dir, None, false);
        assert!(ret.is_err_and(|e| e.to_string().as_str() == "Timed out"));
    }
 }
--- a/crates/call/src/call_impl/room.rs
+++ b/crates/call/src/call_impl/room.rs
@@ -10,10 +10,10 @@ use client::{
 };
 use collections::{BTreeMap, HashMap, HashSet};
 use fs::Fs;
-use futures::{FutureExt, StreamExt};
+use futures::StreamExt;
 use gpui::{
-    App, AppContext as _, AsyncApp, Context, Entity, EventEmitter, ScreenCaptureSource,
-    ScreenCaptureStream, Task, WeakEntity,
+    App, AppContext as _, AsyncApp, Context, Entity, EventEmitter, FutureExt as _,
+    ScreenCaptureSource, ScreenCaptureStream, Task, Timeout, WeakEntity,
 };
 use gpui_tokio::Tokio;
 use language::LanguageRegistry;
@@ -370,57 +370,53 @@ impl Room {
                    })?;

                // Wait for client to re-establish a connection to the server.
-                {
-                    let mut reconnection_timeout =
-                        cx.background_executor().timer(RECONNECT_TIMEOUT).fuse();
-                    let client_reconnection = async {
-                        let mut remaining_attempts = 3;
-                        while remaining_attempts > 0 {
-                            if client_status.borrow().is_connected() {
-                                log::info!("client reconnected, attempting to rejoin room");
+                let executor = cx.background_executor().clone();
+                let client_reconnection = async {
+                    let mut remaining_attempts = 3;
+                    while remaining_attempts > 0 {
+                        if client_status.borrow().is_connected() {
+                            log::info!("client reconnected, attempting to rejoin room");

-                                let Some(this) = this.upgrade() else { break };
-                                match this.update(cx, |this, cx| this.rejoin(cx)) {
-                                    Ok(task) => {
-                                        if task.await.log_err().is_some() {
-                                            return true;
-                                        } else {
-                                            remaining_attempts -= 1;
-                                        }
+                            let Some(this) = this.upgrade() else { break };
+                            match this.update(cx, |this, cx| this.rejoin(cx)) {
+                                Ok(task) => {
+                                    if task.await.log_err().is_some() {
+                                        return true;
+                                    } else {
+                                        remaining_attempts -= 1;
                                    }
-                                    Err(_app_dropped) => return false,
                                }
-                            } else if client_status.borrow().is_signed_out() {
-                                return false;
+                                Err(_app_dropped) => return false,
                            }
-
-                            log::info!(
-                                "waiting for client status change, remaining attempts {}",
-                                remaining_attempts
-                            );
-                            client_status.next().await;
+                        } else if client_status.borrow().is_signed_out() {
+                            return false;
                        }
-                        false
+
+                        log::info!(
+                            "waiting for client status change, remaining attempts {}",
+                            remaining_attempts
+                        );
+                        client_status.next().await;
                    }
-                    .fuse();
-                    futures::pin_mut!(client_reconnection);
+                    false
+                };

-                    futures::select_biased! {
-                        reconnected = client_reconnection => {
-                            if reconnected {
-                                log::info!("successfully reconnected to room");
-                                // If we successfully joined the room, go back around the loop
-                                // waiting for future connection status changes.
-                                continue;
-                            }
-                        }
-                        _ = reconnection_timeout => {
-                            log::info!("room reconnection timeout expired");
-                        }
+                match client_reconnection
+                    .with_timeout(RECONNECT_TIMEOUT, &executor)
+                    .await
+                {
+                    Ok(true) => {
+                        log::info!("successfully reconnected to room");
+                        // If we successfully joined the room, go back around the loop
+                        // waiting for future connection status changes.
+                        continue;
+                    }
+                    Ok(false) => break,
+                    Err(Timeout) => {
+                        log::info!("room reconnection timeout expired");
+                        break;
                    }
                }
-
-                break;
            }
        }

--- a/crates/cli/src/main.rs
+++ b/crates/cli/src/main.rs
@@ -957,17 +957,14 @@ mod mac_os {
    ) -> Result<()> {
        use anyhow::bail;

-        let app_id_prompt = format!("id of app \"{}\"", channel.display_name());
-        let app_id_output = Command::new("osascript")
+        let app_path_prompt = format!(
+            "POSIX path of (path to application \"{}\")",
+            channel.display_name()
+        );
+        let app_path_output = Command::new("osascript")
            .arg("-e")
-            .arg(&app_id_prompt)
+            .arg(&app_path_prompt)
            .output()?;
-        if !app_id_output.status.success() {
-            bail!("Could not determine app id for {}", channel.display_name());
-        }
-        let app_name = String::from_utf8(app_id_output.stdout)?.trim().to_owned();
-        let app_path_prompt = format!("kMDItemCFBundleIdentifier == '{app_name}'");
-        let app_path_output = Command::new("mdfind").arg(app_path_prompt).output()?;
        if !app_path_output.status.success() {
            bail!(
                "Could not determine app path for {}",
--- a/crates/client/src/telemetry.rs
+++ b/crates/client/src/telemetry.rs
@@ -340,22 +340,35 @@ impl Telemetry {
    }

    pub fn log_edit_event(self: &Arc<Self>, environment: &'static str, is_via_ssh: bool) {
+        static LAST_EVENT_TIME: Mutex<Option<Instant>> = Mutex::new(None);
+
        let mut state = self.state.lock();
        let period_data = state.event_coalescer.log_event(environment);
        drop(state);

-        if let Some((start, end, environment)) = period_data {
-            let duration = end
-                .saturating_duration_since(start)
-                .min(Duration::from_secs(60 * 60 * 24))
-                .as_millis() as i64;
+        if let Some(mut last_event) = LAST_EVENT_TIME.try_lock() {
+            let current_time = std::time::Instant::now();
+            let last_time = last_event.get_or_insert(current_time);

-            telemetry::event!(
-                "Editor Edited",
-                duration = duration,
-                environment = environment,
-                is_via_ssh = is_via_ssh
-            );
+            if current_time.duration_since(*last_time) > Duration::from_secs(60 * 10) {
+                *last_time = current_time;
+            } else {
+                return;
+            }
+
+            if let Some((start, end, environment)) = period_data {
+                let duration = end
+                    .saturating_duration_since(start)
+                    .min(Duration::from_secs(60 * 60 * 24))
+                    .as_millis() as i64;
+
+                telemetry::event!(
+                    "Editor Edited",
+                    duration = duration,
+                    environment = environment,
+                    is_via_ssh = is_via_ssh
+                );
+            }
        }
    }

--- a/crates/client/src/test.rs
+++ b/crates/client/src/test.rs
@@ -1,16 +1,12 @@
 use crate::{Client, Connection, Credentials, EstablishConnectionError, UserStore};
 use anyhow::{Context as _, Result, anyhow};
-use chrono::Duration;
 use cloud_api_client::{AuthenticatedUser, GetAuthenticatedUserResponse, PlanInfo};
 use cloud_llm_client::{CurrentUsage, Plan, UsageData, UsageLimit};
 use futures::{StreamExt, stream::BoxStream};
 use gpui::{AppContext as _, BackgroundExecutor, Entity, TestAppContext};
 use http_client::{AsyncBody, Method, Request, http};
 use parking_lot::Mutex;
-use rpc::{
-    ConnectionId, Peer, Receipt, TypedEnvelope,
-    proto::{self, GetPrivateUserInfo, GetPrivateUserInfoResponse},
-};
+use rpc::{ConnectionId, Peer, Receipt, TypedEnvelope, proto};
 use std::sync::Arc;

 pub struct FakeServer {
@@ -187,50 +183,27 @@ impl FakeServer {
    pub async fn receive<M: proto::EnvelopedMessage>(&self) -> Result<TypedEnvelope<M>> {
        self.executor.start_waiting();

-        loop {
-            let message = self
-                .state
-                .lock()
-                .incoming
-                .as_mut()
-                .expect("not connected")
-                .next()
-                .await
-                .context("other half hung up")?;
-            self.executor.finish_waiting();
-            let type_name = message.payload_type_name();
-            let message = message.into_any();
+        let message = self
+            .state
+            .lock()
+            .incoming
+            .as_mut()
+            .expect("not connected")
+            .next()
+            .await
+            .context("other half hung up")?;
+        self.executor.finish_waiting();
+        let type_name = message.payload_type_name();
+        let message = message.into_any();

-            if message.is::<TypedEnvelope<M>>() {
-                return Ok(*message.downcast().unwrap());
-            }
-
-            let accepted_tos_at = chrono::Utc::now()
-                .checked_sub_signed(Duration::hours(5))
-                .expect("failed to build accepted_tos_at")
-                .timestamp() as u64;
-
-            if message.is::<TypedEnvelope<GetPrivateUserInfo>>() {
-                self.respond(
-                    message
-                        .downcast::<TypedEnvelope<GetPrivateUserInfo>>()
-                        .unwrap()
-                        .receipt(),
-                    GetPrivateUserInfoResponse {
-                        metrics_id: "the-metrics-id".into(),
-                        staff: false,
-                        flags: Default::default(),
-                        accepted_tos_at: Some(accepted_tos_at),
-                    },
-                );
-                continue;
-            }
-
-            panic!(
-                "fake server received unexpected message type: {:?}",
-                type_name
-            );
+        if message.is::<TypedEnvelope<M>>() {
+            return Ok(*message.downcast().unwrap());
        }
+
+        panic!(
+            "fake server received unexpected message type: {:?}",
+            type_name
+        );
    }

    pub fn respond<T: proto::RequestMessage>(&self, receipt: Receipt<T>, response: T::Response) {
--- a/crates/client/src/user.rs
+++ b/crates/client/src/user.rs
@@ -177,7 +177,6 @@ impl UserStore {
        let (mut current_user_tx, current_user_rx) = watch::channel();
        let (update_contacts_tx, mut update_contacts_rx) = mpsc::unbounded();
        let rpc_subscriptions = vec![
-            client.add_message_handler(cx.weak_entity(), Self::handle_update_plan),
            client.add_message_handler(cx.weak_entity(), Self::handle_update_contacts),
            client.add_message_handler(cx.weak_entity(), Self::handle_update_invite_info),
            client.add_message_handler(cx.weak_entity(), Self::handle_show_contacts),
@@ -343,26 +342,6 @@ impl UserStore {
        Ok(())
    }

-    async fn handle_update_plan(
-        this: Entity<Self>,
-        _message: TypedEnvelope<proto::UpdateUserPlan>,
-        mut cx: AsyncApp,
-    ) -> Result<()> {
-        let client = this
-            .read_with(&cx, |this, _| this.client.upgrade())?
-            .context("client was dropped")?;
-
-        let response = client
-            .cloud_client()
-            .get_authenticated_user()
-            .await
-            .context("failed to fetch authenticated user")?;
-
-        this.update(&mut cx, |this, cx| {
-            this.update_authenticated_user(response, cx);
-        })
-    }
-
    fn update_contacts(&mut self, message: UpdateContacts, cx: &Context<Self>) -> Task<Result<()>> {
        match message {
            UpdateContacts::Wait(barrier) => {
@@ -1019,19 +998,6 @@ impl RequestUsage {
        }
    }

-    pub fn from_proto(amount: u32, limit: proto::UsageLimit) -> Option<Self> {
-        let limit = match limit.variant? {
-            proto::usage_limit::Variant::Limited(limited) => {
-                UsageLimit::Limited(limited.limit as i32)
-            }
-            proto::usage_limit::Variant::Unlimited(_) => UsageLimit::Unlimited,
-        };
-        Some(RequestUsage {
-            limit,
-            amount: amount as i32,
-        })
-    }
-
    fn from_headers(
        limit_name: &str,
        amount_name: &str,
--- a/crates/collab/Cargo.toml
+++ b/crates/collab/Cargo.toml
@@ -19,7 +19,6 @@ test-support = ["sqlite"]

 [dependencies]
 anyhow.workspace = true
-async-stripe.workspace = true
 async-trait.workspace = true
 async-tungstenite.workspace = true
 aws-config = { version = "1.1.5" }
@@ -30,16 +29,13 @@ axum-extra = { version = "0.4", features = ["erased-json"] }
 base64.workspace = true
 chrono.workspace = true
 clock.workspace = true
-cloud_llm_client.workspace = true
 collections.workspace = true
 dashmap.workspace = true
-derive_more.workspace = true
 envy = "0.4.2"
 futures.workspace = true
 gpui.workspace = true
 hex.workspace = true
 http_client.workspace = true
-jsonwebtoken.workspace = true
 livekit_api.workspace = true
 log.workspace = true
 nanoid.workspace = true
@@ -65,7 +61,6 @@ subtle.workspace = true
 supermaven_api.workspace = true
 telemetry_events.workspace = true
 text.workspace = true
-thiserror.workspace = true
 time.workspace = true
 tokio = { workspace = true, features = ["full"] }
 toml.workspace = true
@@ -136,6 +131,3 @@ util.workspace = true
 workspace = { workspace = true, features = ["test-support"] }
 worktree = { workspace = true, features = ["test-support"] }
 zlog.workspace = true
-
-[package.metadata.cargo-machete]
-ignored = ["async-stripe"]
--- a/crates/collab/k8s/collab.template.yml
+++ b/crates/collab/k8s/collab.template.yml
@@ -219,12 +219,6 @@ spec:
                secretKeyRef:
                  name: slack
                  key: panics_webhook
-            - name: STRIPE_API_KEY
-              valueFrom:
-                secretKeyRef:
-                  name: stripe
-                  key: api_key
-                  optional: true
            - name: COMPLETE_WITH_LANGUAGE_MODEL_RATE_LIMIT_PER_HOUR
              value: "1000"
            - name: SUPERMAVEN_ADMIN_API_KEY
--- a/crates/collab/migrations.sqlite/20221109000000_test_schema.sql
+++ b/crates/collab/migrations.sqlite/20221109000000_test_schema.sql
@@ -474,67 +474,6 @@ CREATE UNIQUE INDEX "index_extensions_external_id" ON "extensions" ("external_id

 CREATE INDEX "index_extensions_total_download_count" ON "extensions" ("total_download_count");

-CREATE TABLE rate_buckets (
-    user_id INT NOT NULL,
-    rate_limit_name VARCHAR(255) NOT NULL,
-    token_count INT NOT NULL,
-    last_refill TIMESTAMP WITHOUT TIME ZONE NOT NULL,
-    PRIMARY KEY (user_id, rate_limit_name),
-    FOREIGN KEY (user_id) REFERENCES users (id)
-);
-
-CREATE INDEX idx_user_id_rate_limit ON rate_buckets (user_id, rate_limit_name);
-
-CREATE TABLE IF NOT EXISTS billing_preferences (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    user_id INTEGER NOT NULL REFERENCES users (id),
-    max_monthly_llm_usage_spending_in_cents INTEGER NOT NULL,
-    model_request_overages_enabled bool NOT NULL DEFAULT FALSE,
-    model_request_overages_spend_limit_in_cents integer NOT NULL DEFAULT 0
-);
-
-CREATE UNIQUE INDEX "uix_billing_preferences_on_user_id" ON billing_preferences (user_id);
-
-CREATE TABLE IF NOT EXISTS billing_customers (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    user_id INTEGER NOT NULL REFERENCES users (id),
-    has_overdue_invoices BOOLEAN NOT NULL DEFAULT FALSE,
-    stripe_customer_id TEXT NOT NULL,
-    trial_started_at TIMESTAMP
-);
-
-CREATE UNIQUE INDEX "uix_billing_customers_on_user_id" ON billing_customers (user_id);
-
-CREATE UNIQUE INDEX "uix_billing_customers_on_stripe_customer_id" ON billing_customers (stripe_customer_id);
-
-CREATE TABLE IF NOT EXISTS billing_subscriptions (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    billing_customer_id INTEGER NOT NULL REFERENCES billing_customers (id),
-    stripe_subscription_id TEXT NOT NULL,
-    stripe_subscription_status TEXT NOT NULL,
-    stripe_cancel_at TIMESTAMP,
-    stripe_cancellation_reason TEXT,
-    kind TEXT,
-    stripe_current_period_start BIGINT,
-    stripe_current_period_end BIGINT
-);
-
-CREATE INDEX "ix_billing_subscriptions_on_billing_customer_id" ON billing_subscriptions (billing_customer_id);
-
-CREATE UNIQUE INDEX "uix_billing_subscriptions_on_stripe_subscription_id" ON billing_subscriptions (stripe_subscription_id);
-
-CREATE TABLE IF NOT EXISTS processed_stripe_events (
-    stripe_event_id TEXT PRIMARY KEY,
-    stripe_event_type TEXT NOT NULL,
-    stripe_event_created_timestamp INTEGER NOT NULL,
-    processed_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
-);
-
-CREATE INDEX "ix_processed_stripe_events_on_stripe_event_created_timestamp" ON processed_stripe_events (stripe_event_created_timestamp);
-
 CREATE TABLE IF NOT EXISTS "breakpoints" (
    "id" INTEGER PRIMARY KEY AUTOINCREMENT,
    "project_id" INTEGER NOT NULL REFERENCES projects (id) ON DELETE CASCADE,
--- a/crates/collab/migrations/20250816124707_make_admin_required_on_users.sql
+++ b/crates/collab/migrations/20250816124707_make_admin_required_on_users.sql
@@ -0,0 +1,2 @@
+alter table users
+alter column admin set not null;
--- a/crates/collab/migrations/20250816133027_add_orb_customer_id_to_billing_customers.sql
+++ b/crates/collab/migrations/20250816133027_add_orb_customer_id_to_billing_customers.sql
@@ -0,0 +1,2 @@
+alter table billing_customers
+    add column orb_customer_id text;
--- a/crates/collab/migrations/20250816135346_drop_rate_buckets_table.sql
+++ b/crates/collab/migrations/20250816135346_drop_rate_buckets_table.sql
@@ -0,0 +1 @@
+drop table rate_buckets;
--- a/crates/collab/src/api.rs
+++ b/crates/collab/src/api.rs
@@ -1,19 +1,11 @@
-pub mod billing;
 pub mod contributors;
 pub mod events;
 pub mod extensions;
 pub mod ips_file;
 pub mod slack;

-use crate::db::Database;
-use crate::{
-    AppState, Error, Result, auth,
-    db::{User, UserId},
-    rpc,
-};
-use ::rpc::proto;
+use crate::{AppState, Error, Result, auth, db::UserId, rpc};
 use anyhow::Context as _;
-use axum::extract;
 use axum::{
    Extension, Json, Router,
    body::Body,
@@ -25,7 +17,6 @@ use axum::{
    routing::{get, post},
 };
 use axum_extra::response::ErasedJson;
-use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
 use std::sync::{Arc, OnceLock};
 use tower::ServiceBuilder;
@@ -100,10 +91,7 @@ impl std::fmt::Display for SystemIdHeader {

 pub fn routes(rpc_server: Arc<rpc::Server>) -> Router<(), Body> {
    Router::new()
-        .route("/users/look_up", get(look_up_user))
        .route("/users/:id/access_tokens", post(create_access_token))
-        .route("/users/:id/refresh_llm_tokens", post(refresh_llm_tokens))
-        .route("/users/:id/update_plan", post(update_plan))
        .route("/rpc_server_snapshot", get(get_rpc_server_snapshot))
        .merge(contributors::router())
        .layer(
@@ -144,99 +132,6 @@ pub async fn validate_api_token<B>(req: Request<B>, next: Next<B>) -> impl IntoR
    Ok::<_, Error>(next.run(req).await)
 }

-#[derive(Debug, Deserialize)]
-struct LookUpUserParams {
-    identifier: String,
-}
-
-#[derive(Debug, Serialize)]
-struct LookUpUserResponse {
-    user: Option<User>,
-}
-
-async fn look_up_user(
-    Query(params): Query<LookUpUserParams>,
-    Extension(app): Extension<Arc<AppState>>,
-) -> Result<Json<LookUpUserResponse>> {
-    let user = resolve_identifier_to_user(&app.db, &params.identifier).await?;
-    let user = if let Some(user) = user {
-        match user {
-            UserOrId::User(user) => Some(user),
-            UserOrId::Id(id) => app.db.get_user_by_id(id).await?,
-        }
-    } else {
-        None
-    };
-
-    Ok(Json(LookUpUserResponse { user }))
-}
-
-enum UserOrId {
-    User(User),
-    Id(UserId),
-}
-
-async fn resolve_identifier_to_user(
-    db: &Arc<Database>,
-    identifier: &str,
-) -> Result<Option<UserOrId>> {
-    if let Some(identifier) = identifier.parse::<i32>().ok() {
-        let user = db.get_user_by_id(UserId(identifier)).await?;
-
-        return Ok(user.map(UserOrId::User));
-    }
-
-    if identifier.starts_with("cus_") {
-        let billing_customer = db
-            .get_billing_customer_by_stripe_customer_id(&identifier)
-            .await?;
-
-        return Ok(billing_customer.map(|billing_customer| UserOrId::Id(billing_customer.user_id)));
-    }
-
-    if identifier.starts_with("sub_") {
-        let billing_subscription = db
-            .get_billing_subscription_by_stripe_subscription_id(&identifier)
-            .await?;
-
-        if let Some(billing_subscription) = billing_subscription {
-            let billing_customer = db
-                .get_billing_customer_by_id(billing_subscription.billing_customer_id)
-                .await?;
-
-            return Ok(
-                billing_customer.map(|billing_customer| UserOrId::Id(billing_customer.user_id))
-            );
-        } else {
-            return Ok(None);
-        }
-    }
-
-    if identifier.contains('@') {
-        let user = db.get_user_by_email(identifier).await?;
-
-        return Ok(user.map(UserOrId::User));
-    }
-
-    if let Some(user) = db.get_user_by_github_login(identifier).await? {
-        return Ok(Some(UserOrId::User(user)));
-    }
-
-    Ok(None)
-}
-
-#[derive(Deserialize, Debug)]
-struct CreateUserParams {
-    github_user_id: i32,
-    github_login: String,
-    email_address: String,
-    email_confirmation_code: Option<String>,
-    #[serde(default)]
-    admin: bool,
-    #[serde(default)]
-    invite_count: i32,
-}
-
 async fn get_rpc_server_snapshot(
    Extension(rpc_server): Extension<Arc<rpc::Server>>,
 ) -> Result<ErasedJson> {
@@ -295,90 +190,3 @@ async fn create_access_token(
        encrypted_access_token,
    }))
 }
-
-#[derive(Serialize)]
-struct RefreshLlmTokensResponse {}
-
-async fn refresh_llm_tokens(
-    Path(user_id): Path<UserId>,
-    Extension(rpc_server): Extension<Arc<rpc::Server>>,
-) -> Result<Json<RefreshLlmTokensResponse>> {
-    rpc_server.refresh_llm_tokens_for_user(user_id).await;
-
-    Ok(Json(RefreshLlmTokensResponse {}))
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-struct UpdatePlanBody {
-    pub plan: cloud_llm_client::Plan,
-    pub subscription_period: SubscriptionPeriod,
-    pub usage: cloud_llm_client::CurrentUsage,
-    pub trial_started_at: Option<DateTime<Utc>>,
-    pub is_usage_based_billing_enabled: bool,
-    pub is_account_too_young: bool,
-    pub has_overdue_invoices: bool,
-}
-
-#[derive(Debug, PartialEq, Clone, Copy, Serialize, Deserialize)]
-struct SubscriptionPeriod {
-    pub started_at: DateTime<Utc>,
-    pub ended_at: DateTime<Utc>,
-}
-
-#[derive(Serialize)]
-struct UpdatePlanResponse {}
-
-async fn update_plan(
-    Path(user_id): Path<UserId>,
-    Extension(rpc_server): Extension<Arc<rpc::Server>>,
-    extract::Json(body): extract::Json<UpdatePlanBody>,
-) -> Result<Json<UpdatePlanResponse>> {
-    let plan = match body.plan {
-        cloud_llm_client::Plan::ZedFree => proto::Plan::Free,
-        cloud_llm_client::Plan::ZedPro => proto::Plan::ZedPro,
-        cloud_llm_client::Plan::ZedProTrial => proto::Plan::ZedProTrial,
-    };
-
-    let update_user_plan = proto::UpdateUserPlan {
-        plan: plan.into(),
-        trial_started_at: body
-            .trial_started_at
-            .map(|trial_started_at| trial_started_at.timestamp() as u64),
-        is_usage_based_billing_enabled: Some(body.is_usage_based_billing_enabled),
-        usage: Some(proto::SubscriptionUsage {
-            model_requests_usage_amount: body.usage.model_requests.used,
-            model_requests_usage_limit: Some(usage_limit_to_proto(body.usage.model_requests.limit)),
-            edit_predictions_usage_amount: body.usage.edit_predictions.used,
-            edit_predictions_usage_limit: Some(usage_limit_to_proto(
-                body.usage.edit_predictions.limit,
-            )),
-        }),
-        subscription_period: Some(proto::SubscriptionPeriod {
-            started_at: body.subscription_period.started_at.timestamp() as u64,
-            ended_at: body.subscription_period.ended_at.timestamp() as u64,
-        }),
-        account_too_young: Some(body.is_account_too_young),
-        has_overdue_invoices: Some(body.has_overdue_invoices),
-    };
-
-    rpc_server
-        .update_plan_for_user(user_id, update_user_plan)
-        .await?;
-
-    Ok(Json(UpdatePlanResponse {}))
-}
-
-fn usage_limit_to_proto(limit: cloud_llm_client::UsageLimit) -> proto::UsageLimit {
-    proto::UsageLimit {
-        variant: Some(match limit {
-            cloud_llm_client::UsageLimit::Limited(limit) => {
-                proto::usage_limit::Variant::Limited(proto::usage_limit::Limited {
-                    limit: limit as u32,
-                })
-            }
-            cloud_llm_client::UsageLimit::Unlimited => {
-                proto::usage_limit::Variant::Unlimited(proto::usage_limit::Unlimited {})
-            }
-        }),
-    }
-}
--- a/crates/collab/src/api/billing.rs
+++ b/crates/collab/src/api/billing.rs
@@ -1,59 +0,0 @@
-use std::sync::Arc;
-use stripe::SubscriptionStatus;
-
-use crate::AppState;
-use crate::db::billing_subscription::StripeSubscriptionStatus;
-use crate::db::{CreateBillingCustomerParams, billing_customer};
-use crate::stripe_client::{StripeClient, StripeCustomerId};
-
-impl From<SubscriptionStatus> for StripeSubscriptionStatus {
-    fn from(value: SubscriptionStatus) -> Self {
-        match value {
-            SubscriptionStatus::Incomplete => Self::Incomplete,
-            SubscriptionStatus::IncompleteExpired => Self::IncompleteExpired,
-            SubscriptionStatus::Trialing => Self::Trialing,
-            SubscriptionStatus::Active => Self::Active,
-            SubscriptionStatus::PastDue => Self::PastDue,
-            SubscriptionStatus::Canceled => Self::Canceled,
-            SubscriptionStatus::Unpaid => Self::Unpaid,
-            SubscriptionStatus::Paused => Self::Paused,
-        }
-    }
-}
-
-/// Finds or creates a billing customer using the provided customer.
-pub async fn find_or_create_billing_customer(
-    app: &Arc<AppState>,
-    stripe_client: &dyn StripeClient,
-    customer_id: &StripeCustomerId,
-) -> anyhow::Result<Option<billing_customer::Model>> {
-    // If we already have a billing customer record associated with the Stripe customer,
-    // there's nothing more we need to do.
-    if let Some(billing_customer) = app
-        .db
-        .get_billing_customer_by_stripe_customer_id(customer_id.0.as_ref())
-        .await?
-    {
-        return Ok(Some(billing_customer));
-    }
-
-    let customer = stripe_client.get_customer(customer_id).await?;
-
-    let Some(email) = customer.email else {
-        return Ok(None);
-    };
-
-    let Some(user) = app.db.get_user_by_email(&email).await? else {
-        return Ok(None);
-    };
-
-    let billing_customer = app
-        .db
-        .create_billing_customer(&CreateBillingCustomerParams {
-            user_id: user.id,
-            stripe_customer_id: customer.id.to_string(),
-        })
-        .await?;
-
-    Ok(Some(billing_customer))
-}
--- a/Show More
+++ b/Show More