diff --git a/.github/ISSUE_TEMPLATE/10_bug_report.yml b/.github/ISSUE_TEMPLATE/10_bug_report.yml
index 1bf6c80e40..e132eca1e5 100644
--- a/.github/ISSUE_TEMPLATE/10_bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/10_bug_report.yml
@@ -14,7 +14,7 @@ body:
### Description
diff --git a/.github/actionlint.yml b/.github/actionlint.yml
index 6d8e0107e9..0ee6af8a1d 100644
--- a/.github/actionlint.yml
+++ b/.github/actionlint.yml
@@ -19,27 +19,14 @@ self-hosted-runner:
- namespace-profile-16x32-ubuntu-2004-arm
- namespace-profile-32x64-ubuntu-2004-arm
# Namespace Ubuntu 22.04 (Everything else)
+ - namespace-profile-2x4-ubuntu-2204
- namespace-profile-4x8-ubuntu-2204
- namespace-profile-8x16-ubuntu-2204
- namespace-profile-16x32-ubuntu-2204
- namespace-profile-32x64-ubuntu-2204
- # Namespace Ubuntu 24.04 (like ubuntu-latest)
- - namespace-profile-2x4-ubuntu-2404
# Namespace Limited Preview
- namespace-profile-8x16-ubuntu-2004-arm-m4
- namespace-profile-8x32-ubuntu-2004-arm-m4
# Self Hosted Runners
- self-mini-macos
- self-32vcpu-windows-2022
-
-# Disable shellcheck because it doesn't like powershell
-# This should have been triggered with initial rollout of actionlint
-# but https://github.com/zed-industries/zed/pull/36693
-# somehow caused actionlint to actually check those windows jobs
-# where previously they were being skipped. Likely caused by an
-# unknown bug in actionlint where parsing of `runs-on: [ ]`
-# breaks something else. (yuck)
-paths:
- .github/workflows/{ci,release_nightly}.yml:
- ignore:
- - "shellcheck"
diff --git a/.github/workflows/bump_collab_staging.yml b/.github/workflows/bump_collab_staging.yml
index d400905b4d..d8eaa6019e 100644
--- a/.github/workflows/bump_collab_staging.yml
+++ b/.github/workflows/bump_collab_staging.yml
@@ -8,7 +8,7 @@ on:
jobs:
update-collab-staging-tag:
if: github.repository_owner == 'zed-industries'
- runs-on: namespace-profile-2x4-ubuntu-2404
+ runs-on: ubuntu-latest
steps:
- name: Checkout repository
uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a34833d0fd..f4ba227168 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -37,7 +37,7 @@ jobs:
run_nix: ${{ steps.filter.outputs.run_nix }}
run_actionlint: ${{ steps.filter.outputs.run_actionlint }}
runs-on:
- - namespace-profile-2x4-ubuntu-2404
+ - ubuntu-latest
steps:
- name: Checkout repo
uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
@@ -237,7 +237,7 @@ jobs:
uses: ./.github/actions/build_docs
actionlint:
- runs-on: namespace-profile-2x4-ubuntu-2404
+ runs-on: ubuntu-latest
if: github.repository_owner == 'zed-industries' && needs.job_spec.outputs.run_actionlint == 'true'
needs: [job_spec]
steps:
@@ -418,7 +418,7 @@ jobs:
if: |
github.repository_owner == 'zed-industries' &&
needs.job_spec.outputs.run_tests == 'true'
- runs-on: [self-32vcpu-windows-2022]
+ runs-on: [self-hosted, Windows, X64]
steps:
- name: Environment Setup
run: |
@@ -458,7 +458,7 @@ jobs:
tests_pass:
name: Tests Pass
- runs-on: namespace-profile-2x4-ubuntu-2404
+ runs-on: ubuntu-latest
needs:
- job_spec
- style
@@ -784,7 +784,7 @@ jobs:
bundle-windows-x64:
timeout-minutes: 120
name: Create a Windows installer
- runs-on: [self-32vcpu-windows-2022]
+ runs-on: [self-hosted, Windows, X64]
if: contains(github.event.pull_request.labels.*.name, 'run-bundling')
# if: (startsWith(github.ref, 'refs/tags/v') || contains(github.event.pull_request.labels.*.name, 'run-bundling'))
needs: [windows_tests]
diff --git a/.github/workflows/danger.yml b/.github/workflows/danger.yml
index 3f84179278..15c82643ae 100644
--- a/.github/workflows/danger.yml
+++ b/.github/workflows/danger.yml
@@ -12,7 +12,7 @@ on:
jobs:
danger:
if: github.repository_owner == 'zed-industries'
- runs-on: namespace-profile-2x4-ubuntu-2404
+ runs-on: ubuntu-latest
steps:
- uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
diff --git a/.github/workflows/release_nightly.yml b/.github/workflows/release_nightly.yml
index 2026ee7b73..5d63c34edd 100644
--- a/.github/workflows/release_nightly.yml
+++ b/.github/workflows/release_nightly.yml
@@ -59,7 +59,7 @@ jobs:
timeout-minutes: 60
name: Run tests on Windows
if: github.repository_owner == 'zed-industries'
- runs-on: [self-32vcpu-windows-2022]
+ runs-on: [self-hosted, Windows, X64]
steps:
- name: Checkout repo
uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
@@ -248,7 +248,7 @@ jobs:
timeout-minutes: 60
name: Create a Windows installer
if: github.repository_owner == 'zed-industries'
- runs-on: [self-32vcpu-windows-2022]
+ runs-on: [self-hosted, Windows, X64]
needs: windows-tests
env:
AZURE_TENANT_ID: ${{ secrets.AZURE_SIGNING_TENANT_ID }}
@@ -290,7 +290,7 @@ jobs:
update-nightly-tag:
name: Update nightly tag
if: github.repository_owner == 'zed-industries'
- runs-on: namespace-profile-2x4-ubuntu-2404
+ runs-on: ubuntu-latest
needs:
- bundle-mac
- bundle-linux-x86
diff --git a/.github/workflows/script_checks.yml b/.github/workflows/script_checks.yml
index 5dbfc9cb7f..c32a433e46 100644
--- a/.github/workflows/script_checks.yml
+++ b/.github/workflows/script_checks.yml
@@ -12,7 +12,7 @@ jobs:
shellcheck:
name: "ShellCheck Scripts"
if: github.repository_owner == 'zed-industries'
- runs-on: namespace-profile-2x4-ubuntu-2404
+ runs-on: ubuntu-latest
steps:
- uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
diff --git a/Cargo.lock b/Cargo.lock
index 42649b137f..6063530e9f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -39,26 +39,6 @@ dependencies = [
"workspace-hack",
]
-[[package]]
-name = "acp_tools"
-version = "0.1.0"
-dependencies = [
- "agent-client-protocol",
- "collections",
- "gpui",
- "language",
- "markdown",
- "project",
- "serde",
- "serde_json",
- "settings",
- "theme",
- "ui",
- "util",
- "workspace",
- "workspace-hack",
-]
-
[[package]]
name = "action_log"
version = "0.1.0"
@@ -191,12 +171,11 @@ dependencies = [
[[package]]
name = "agent-client-protocol"
-version = "0.0.31"
+version = "0.0.30"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "289eb34ee17213dadcca47eedadd386a5e7678094095414e475965d1bcca2860"
+checksum = "5f792e009ba59b137ee1db560bc37e567887ad4b5af6f32181d381fff690e2d4"
dependencies = [
"anyhow",
- "async-broadcast",
"futures 0.3.31",
"log",
"parking_lot",
@@ -285,10 +264,10 @@ name = "agent_servers"
version = "0.1.0"
dependencies = [
"acp_thread",
- "acp_tools",
"action_log",
"agent-client-protocol",
"agent_settings",
+ "agentic-coding-protocol",
"anyhow",
"client",
"collections",
@@ -403,7 +382,6 @@ dependencies = [
"parking_lot",
"paths",
"picker",
- "postage",
"pretty_assertions",
"project",
"prompt_store",
@@ -443,6 +421,24 @@ dependencies = [
"zed_actions",
]
+[[package]]
+name = "agentic-coding-protocol"
+version = "0.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3e6ae951b36fa2f8d9dd6e1af6da2fcaba13d7c866cf6a9e65deda9dc6c5fe4"
+dependencies = [
+ "anyhow",
+ "chrono",
+ "derive_more 2.0.1",
+ "futures 0.3.31",
+ "log",
+ "parking_lot",
+ "schemars",
+ "semver",
+ "serde",
+ "serde_json",
+]
+
[[package]]
name = "ahash"
version = "0.7.8"
@@ -858,7 +854,7 @@ dependencies = [
"anyhow",
"async-trait",
"collections",
- "derive_more",
+ "derive_more 0.99.19",
"extension",
"futures 0.3.31",
"gpui",
@@ -921,7 +917,7 @@ dependencies = [
"clock",
"collections",
"ctor",
- "derive_more",
+ "derive_more 0.99.19",
"gpui",
"icons",
"indoc",
@@ -958,7 +954,7 @@ dependencies = [
"cloud_llm_client",
"collections",
"component",
- "derive_more",
+ "derive_more 0.99.19",
"diffy",
"editor",
"feature_flags",
@@ -3071,7 +3067,7 @@ dependencies = [
"cocoa 0.26.0",
"collections",
"credentials_provider",
- "derive_more",
+ "derive_more 0.99.19",
"feature_flags",
"fs",
"futures 0.3.31",
@@ -3503,7 +3499,7 @@ name = "command_palette_hooks"
version = "0.1.0"
dependencies = [
"collections",
- "derive_more",
+ "derive_more 0.99.19",
"gpui",
"workspace-hack",
]
@@ -4054,7 +4050,6 @@ dependencies = [
name = "crashes"
version = "0.1.0"
dependencies = [
- "bincode",
"crash-handler",
"log",
"mach2 0.5.0",
@@ -4064,7 +4059,6 @@ dependencies = [
"serde",
"serde_json",
"smol",
- "system_specs",
"workspace-hack",
]
@@ -4666,6 +4660,27 @@ dependencies = [
"syn 2.0.101",
]
+[[package]]
+name = "derive_more"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "093242cf7570c207c83073cf82f79706fe7b8317e98620a47d5be7c3d8497678"
+dependencies = [
+ "derive_more-impl",
+]
+
+[[package]]
+name = "derive_more-impl"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bda628edc44c4bb645fbe0f758797143e4e07926f7ebf4e9bdfbd3d2ce621df3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.101",
+ "unicode-xid",
+]
+
[[package]]
name = "derive_refineable"
version = "0.1.0"
@@ -4686,6 +4701,7 @@ dependencies = [
"component",
"ctor",
"editor",
+ "futures 0.3.31",
"gpui",
"indoc",
"language",
@@ -5722,10 +5738,14 @@ dependencies = [
name = "feedback"
version = "0.1.0"
dependencies = [
+ "client",
"editor",
"gpui",
+ "human_bytes",
"menu",
- "system_specs",
+ "release_channel",
+ "serde",
+ "sysinfo",
"ui",
"urlencoding",
"util",
@@ -6401,7 +6421,7 @@ dependencies = [
"askpass",
"async-trait",
"collections",
- "derive_more",
+ "derive_more 0.99.19",
"futures 0.3.31",
"git2",
"gpui",
@@ -7431,7 +7451,7 @@ dependencies = [
"core-video",
"cosmic-text",
"ctor",
- "derive_more",
+ "derive_more 0.99.19",
"embed-resource",
"env_logger 0.11.8",
"etagere",
@@ -7519,7 +7539,6 @@ dependencies = [
name = "gpui_tokio"
version = "0.1.0"
dependencies = [
- "anyhow",
"gpui",
"tokio",
"util",
@@ -7956,7 +7975,7 @@ version = "0.1.0"
dependencies = [
"anyhow",
"bytes 1.10.1",
- "derive_more",
+ "derive_more 0.99.19",
"futures 0.3.31",
"http 1.3.1",
"http-body 1.0.1",
@@ -8468,7 +8487,6 @@ dependencies = [
"theme",
"ui",
"util",
- "util_macros",
"workspace",
"workspace-hack",
"zed_actions",
@@ -11615,12 +11633,6 @@ dependencies = [
"hmac",
]
-[[package]]
-name = "pciid-parser"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0008e816fcdaf229cdd540e9b6ca2dc4a10d65c31624abb546c6420a02846e61"
-
[[package]]
name = "pem"
version = "3.0.5"
@@ -13521,7 +13533,6 @@ dependencies = [
"smol",
"sysinfo",
"telemetry_events",
- "thiserror 2.0.12",
"toml 0.8.20",
"unindent",
"util",
@@ -14361,10 +14372,12 @@ version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fe8c9d1c68d67dd9f97ecbc6f932b60eb289c5dbddd8aa1405484a8fd2fcd984"
dependencies = [
+ "chrono",
"dyn-clone",
"indexmap",
"ref-cast",
"schemars_derive",
+ "semver",
"serde",
"serde_json",
]
@@ -16140,21 +16153,6 @@ dependencies = [
"winx",
]
-[[package]]
-name = "system_specs"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "client",
- "gpui",
- "human_bytes",
- "pciid-parser",
- "release_channel",
- "serde",
- "sysinfo",
- "workspace-hack",
-]
-
[[package]]
name = "tab_switcher"
version = "0.1.0"
@@ -16448,7 +16446,7 @@ version = "0.1.0"
dependencies = [
"anyhow",
"collections",
- "derive_more",
+ "derive_more 0.99.19",
"fs",
"futures 0.3.31",
"gpui",
@@ -19789,6 +19787,7 @@ dependencies = [
"any_vec",
"anyhow",
"async-recursion",
+ "bincode",
"call",
"client",
"clock",
@@ -19807,7 +19806,6 @@ dependencies = [
"node_runtime",
"parking_lot",
"postage",
- "pretty_assertions",
"project",
"remote",
"schemars",
@@ -19963,6 +19961,7 @@ dependencies = [
"rustix 1.0.7",
"rustls 0.23.26",
"rustls-webpki 0.103.1",
+ "schemars",
"scopeguard",
"sea-orm",
"sea-query-binder",
@@ -20398,7 +20397,6 @@ dependencies = [
name = "zed"
version = "0.202.0"
dependencies = [
- "acp_tools",
"activity_indicator",
"agent",
"agent_servers",
@@ -20414,7 +20412,6 @@ dependencies = [
"auto_update",
"auto_update_ui",
"backtrace",
- "bincode",
"breadcrumbs",
"call",
"channel",
@@ -20513,7 +20510,6 @@ dependencies = [
"supermaven",
"svg_preview",
"sysinfo",
- "system_specs",
"tab_switcher",
"task",
"tasks_ui",
diff --git a/Cargo.toml b/Cargo.toml
index 6ec243a9b9..b13795e1e1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,6 @@
[workspace]
resolver = "2"
members = [
- "crates/acp_tools",
"crates/acp_thread",
"crates/action_log",
"crates/activity_indicator",
@@ -156,7 +155,6 @@ members = [
"crates/streaming_diff",
"crates/sum_tree",
"crates/supermaven",
- "crates/system_specs",
"crates/supermaven_api",
"crates/svg_preview",
"crates/tab_switcher",
@@ -228,7 +226,6 @@ edition = "2024"
# Workspace member crates
#
-acp_tools = { path = "crates/acp_tools" }
acp_thread = { path = "crates/acp_thread" }
action_log = { path = "crates/action_log" }
agent = { path = "crates/agent" }
@@ -384,7 +381,6 @@ streaming_diff = { path = "crates/streaming_diff" }
sum_tree = { path = "crates/sum_tree" }
supermaven = { path = "crates/supermaven" }
supermaven_api = { path = "crates/supermaven_api" }
-system_specs = { path = "crates/system_specs" }
tab_switcher = { path = "crates/tab_switcher" }
task = { path = "crates/task" }
tasks_ui = { path = "crates/tasks_ui" }
@@ -426,7 +422,8 @@ zlog_settings = { path = "crates/zlog_settings" }
# External crates
#
-agent-client-protocol = "0.0.31"
+agentic-coding-protocol = "0.0.10"
+agent-client-protocol = "0.0.30"
aho-corasick = "1.1"
alacritty_terminal = { git = "https://github.com/zed-industries/alacritty.git", branch = "add-hush-login-flag" }
any_vec = "0.14"
@@ -453,7 +450,6 @@ aws-sdk-bedrockruntime = { version = "1.80.0", features = [
aws-smithy-runtime-api = { version = "1.7.4", features = ["http-1x", "client"] }
aws-smithy-types = { version = "1.3.0", features = ["http-body-1-x"] }
base64 = "0.22"
-bincode = "1.2.1"
bitflags = "2.6.0"
blade-graphics = { git = "https://github.com/kvark/blade", rev = "e0ec4e720957edd51b945b64dd85605ea54bcfe5" }
blade-macros = { git = "https://github.com/kvark/blade", rev = "e0ec4e720957edd51b945b64dd85605ea54bcfe5" }
@@ -497,7 +493,6 @@ handlebars = "4.3"
heck = "0.5"
heed = { version = "0.21.0", features = ["read-txn-no-tls"] }
hex = "0.4.3"
-human_bytes = "0.4.1"
html5ever = "0.27.0"
http = "1.1"
http-body = "1.0"
@@ -537,7 +532,6 @@ palette = { version = "0.7.5", default-features = false, features = ["std"] }
parking_lot = "0.12.1"
partial-json-fixer = "0.5.3"
parse_int = "0.9"
-pciid-parser = "0.8.0"
pathdiff = "0.2"
pet = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "845945b830297a50de0e24020b980a65e4820559" }
pet-conda = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "845945b830297a50de0e24020b980a65e4820559" }
diff --git a/Procfile.web b/Procfile.web
deleted file mode 100644
index 8140555144..0000000000
--- a/Procfile.web
+++ /dev/null
@@ -1,2 +0,0 @@
-postgrest_llm: postgrest crates/collab/postgrest_llm.conf
-website: cd ../zed.dev; npm run dev -- --port=3000
diff --git a/assets/icons/attach.svg b/assets/icons/attach.svg
deleted file mode 100644
index f923a3c7c8..0000000000
--- a/assets/icons/attach.svg
+++ /dev/null
@@ -1,3 +0,0 @@
-
diff --git a/assets/icons/copy.svg b/assets/icons/copy.svg
index aba193930b..bca13f8d56 100644
--- a/assets/icons/copy.svg
+++ b/assets/icons/copy.svg
@@ -1,4 +1 @@
-
+
diff --git a/assets/icons/pencil_unavailable.svg b/assets/icons/pencil_unavailable.svg
deleted file mode 100644
index 4241d766ac..0000000000
--- a/assets/icons/pencil_unavailable.svg
+++ /dev/null
@@ -1,6 +0,0 @@
-
diff --git a/assets/icons/terminal_ghost.svg b/assets/icons/terminal_ghost.svg
deleted file mode 100644
index 7d0d0e068e..0000000000
--- a/assets/icons/terminal_ghost.svg
+++ /dev/null
@@ -1,4 +0,0 @@
-
diff --git a/assets/icons/tool_think.svg b/assets/icons/tool_think.svg
index 773f5e7fa7..efd5908a90 100644
--- a/assets/icons/tool_think.svg
+++ b/assets/icons/tool_think.svg
@@ -1,3 +1,3 @@
diff --git a/assets/images/acp_grid.svg b/assets/images/acp_grid.svg
deleted file mode 100644
index 8ebff8e1bc..0000000000
--- a/assets/images/acp_grid.svg
+++ /dev/null
@@ -1,1257 +0,0 @@
-
diff --git a/assets/images/acp_logo.svg b/assets/images/acp_logo.svg
deleted file mode 100644
index efaa46707b..0000000000
--- a/assets/images/acp_logo.svg
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/assets/images/acp_logo_serif.svg b/assets/images/acp_logo_serif.svg
deleted file mode 100644
index 6bc359cf82..0000000000
--- a/assets/images/acp_logo_serif.svg
+++ /dev/null
@@ -1,2 +0,0 @@
-
-
diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json
index 3cca560c00..955e68f5a9 100644
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -16,6 +16,7 @@
"up": "menu::SelectPrevious",
"enter": "menu::Confirm",
"ctrl-enter": "menu::SecondaryConfirm",
+ "ctrl-escape": "menu::Cancel",
"ctrl-c": "menu::Cancel",
"escape": "menu::Cancel",
"alt-shift-enter": "menu::Restart",
@@ -40,7 +41,7 @@
"shift-f11": "debugger::StepOut",
"f11": "zed::ToggleFullScreen",
"ctrl-alt-z": "edit_prediction::RateCompletions",
- "ctrl-alt-shift-i": "edit_prediction::ToggleMenu",
+ "ctrl-shift-i": "edit_prediction::ToggleMenu",
"ctrl-alt-l": "lsp_tool::ToggleMenu"
}
},
@@ -120,7 +121,7 @@
"alt-g m": "git::OpenModifiedFiles",
"menu": "editor::OpenContextMenu",
"shift-f10": "editor::OpenContextMenu",
- "ctrl-alt-shift-e": "editor::ToggleEditPrediction",
+ "ctrl-shift-e": "editor::ToggleEditPrediction",
"f9": "editor::ToggleBreakpoint",
"shift-f9": "editor::EditLogBreakpoint"
}
@@ -855,7 +856,7 @@
"ctrl-backspace": ["project_panel::Delete", { "skip_prompt": false }],
"ctrl-delete": ["project_panel::Delete", { "skip_prompt": false }],
"alt-ctrl-r": "project_panel::RevealInFileManager",
- "ctrl-shift-enter": "workspace::OpenWithSystem",
+ "ctrl-shift-enter": "project_panel::OpenWithSystem",
"alt-d": "project_panel::CompareMarkedFiles",
"shift-find": "project_panel::NewSearchInDirectory",
"ctrl-alt-shift-f": "project_panel::NewSearchInDirectory",
@@ -1194,16 +1195,9 @@
"ctrl-1": "onboarding::ActivateBasicsPage",
"ctrl-2": "onboarding::ActivateEditingPage",
"ctrl-3": "onboarding::ActivateAISetupPage",
- "ctrl-enter": "onboarding::Finish",
- "alt-shift-l": "onboarding::SignIn",
+ "ctrl-escape": "onboarding::Finish",
+ "alt-tab": "onboarding::SignIn",
"alt-shift-a": "onboarding::OpenAccount"
}
- },
- {
- "context": "InvalidBuffer",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-shift-enter": "workspace::OpenWithSystem"
- }
}
]
diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json
index e72f4174ff..8b18299a91 100644
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -915,7 +915,7 @@
"cmd-backspace": ["project_panel::Trash", { "skip_prompt": true }],
"cmd-delete": ["project_panel::Delete", { "skip_prompt": false }],
"alt-cmd-r": "project_panel::RevealInFileManager",
- "ctrl-shift-enter": "workspace::OpenWithSystem",
+ "ctrl-shift-enter": "project_panel::OpenWithSystem",
"alt-d": "project_panel::CompareMarkedFiles",
"cmd-alt-backspace": ["project_panel::Delete", { "skip_prompt": false }],
"cmd-alt-shift-f": "project_panel::NewSearchInDirectory",
@@ -1301,12 +1301,5 @@
"alt-tab": "onboarding::SignIn",
"alt-shift-a": "onboarding::OpenAccount"
}
- },
- {
- "context": "InvalidBuffer",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-shift-enter": "workspace::OpenWithSystem"
- }
}
]
diff --git a/assets/keymaps/default-windows.json b/assets/keymaps/default-windows.json
deleted file mode 100644
index c7a6c3149c..0000000000
--- a/assets/keymaps/default-windows.json
+++ /dev/null
@@ -1,1260 +0,0 @@
-[
- // Standard Windows bindings
- {
- "use_key_equivalents": true,
- "bindings": {
- "home": "menu::SelectFirst",
- "shift-pageup": "menu::SelectFirst",
- "pageup": "menu::SelectFirst",
- "end": "menu::SelectLast",
- "shift-pagedown": "menu::SelectLast",
- "pagedown": "menu::SelectLast",
- "ctrl-n": "menu::SelectNext",
- "tab": "menu::SelectNext",
- "down": "menu::SelectNext",
- "ctrl-p": "menu::SelectPrevious",
- "shift-tab": "menu::SelectPrevious",
- "up": "menu::SelectPrevious",
- "enter": "menu::Confirm",
- "ctrl-enter": "menu::SecondaryConfirm",
- "ctrl-escape": "menu::Cancel",
- "ctrl-c": "menu::Cancel",
- "escape": "menu::Cancel",
- "shift-alt-enter": "menu::Restart",
- "alt-enter": ["picker::ConfirmInput", { "secondary": false }],
- "ctrl-alt-enter": ["picker::ConfirmInput", { "secondary": true }],
- "ctrl-shift-w": "workspace::CloseWindow",
- "shift-escape": "workspace::ToggleZoom",
- "open": "workspace::Open",
- "ctrl-o": "workspace::Open",
- "ctrl-=": ["zed::IncreaseBufferFontSize", { "persist": false }],
- "ctrl-shift-=": ["zed::IncreaseBufferFontSize", { "persist": false }],
- "ctrl--": ["zed::DecreaseBufferFontSize", { "persist": false }],
- "ctrl-0": ["zed::ResetBufferFontSize", { "persist": false }],
- "ctrl-,": "zed::OpenSettings",
- "ctrl-q": "zed::Quit",
- "f4": "debugger::Start",
- "shift-f5": "debugger::Stop",
- "ctrl-shift-f5": "debugger::RerunSession",
- "f6": "debugger::Pause",
- "f7": "debugger::StepOver",
- "ctrl-f11": "debugger::StepInto",
- "shift-f11": "debugger::StepOut",
- "f11": "zed::ToggleFullScreen",
- "ctrl-shift-i": "edit_prediction::ToggleMenu",
- "shift-alt-l": "lsp_tool::ToggleMenu"
- }
- },
- {
- "context": "Picker || menu",
- "use_key_equivalents": true,
- "bindings": {
- "up": "menu::SelectPrevious",
- "down": "menu::SelectNext"
- }
- },
- {
- "context": "Editor",
- "use_key_equivalents": true,
- "bindings": {
- "escape": "editor::Cancel",
- "shift-backspace": "editor::Backspace",
- "backspace": "editor::Backspace",
- "delete": "editor::Delete",
- "tab": "editor::Tab",
- "shift-tab": "editor::Backtab",
- "ctrl-k": "editor::CutToEndOfLine",
- "ctrl-k ctrl-q": "editor::Rewrap",
- "ctrl-k q": "editor::Rewrap",
- "ctrl-backspace": "editor::DeleteToPreviousWordStart",
- "ctrl-delete": "editor::DeleteToNextWordEnd",
- "cut": "editor::Cut",
- "shift-delete": "editor::Cut",
- "ctrl-x": "editor::Cut",
- "copy": "editor::Copy",
- "ctrl-insert": "editor::Copy",
- "ctrl-c": "editor::Copy",
- "paste": "editor::Paste",
- "shift-insert": "editor::Paste",
- "ctrl-v": "editor::Paste",
- "undo": "editor::Undo",
- "ctrl-z": "editor::Undo",
- "redo": "editor::Redo",
- "ctrl-y": "editor::Redo",
- "ctrl-shift-z": "editor::Redo",
- "up": "editor::MoveUp",
- "ctrl-up": "editor::LineUp",
- "ctrl-down": "editor::LineDown",
- "pageup": "editor::MovePageUp",
- "alt-pageup": "editor::PageUp",
- "shift-pageup": "editor::SelectPageUp",
- "home": ["editor::MoveToBeginningOfLine", { "stop_at_soft_wraps": true, "stop_at_indent": true }],
- "down": "editor::MoveDown",
- "pagedown": "editor::MovePageDown",
- "alt-pagedown": "editor::PageDown",
- "shift-pagedown": "editor::SelectPageDown",
- "end": ["editor::MoveToEndOfLine", { "stop_at_soft_wraps": true }],
- "left": "editor::MoveLeft",
- "right": "editor::MoveRight",
- "ctrl-left": "editor::MoveToPreviousWordStart",
- "ctrl-right": "editor::MoveToNextWordEnd",
- "ctrl-home": "editor::MoveToBeginning",
- "ctrl-end": "editor::MoveToEnd",
- "shift-up": "editor::SelectUp",
- "shift-down": "editor::SelectDown",
- "shift-left": "editor::SelectLeft",
- "shift-right": "editor::SelectRight",
- "ctrl-shift-left": "editor::SelectToPreviousWordStart",
- "ctrl-shift-right": "editor::SelectToNextWordEnd",
- "ctrl-shift-home": "editor::SelectToBeginning",
- "ctrl-shift-end": "editor::SelectToEnd",
- "ctrl-a": "editor::SelectAll",
- "ctrl-l": "editor::SelectLine",
- "shift-alt-f": "editor::Format",
- "shift-alt-o": "editor::OrganizeImports",
- "shift-home": ["editor::SelectToBeginningOfLine", { "stop_at_soft_wraps": true, "stop_at_indent": true }],
- "shift-end": ["editor::SelectToEndOfLine", { "stop_at_soft_wraps": true }],
- "ctrl-alt-space": "editor::ShowCharacterPalette",
- "ctrl-;": "editor::ToggleLineNumbers",
- "ctrl-'": "editor::ToggleSelectedDiffHunks",
- "ctrl-\"": "editor::ExpandAllDiffHunks",
- "ctrl-i": "editor::ShowSignatureHelp",
- "alt-g b": "git::Blame",
- "alt-g m": "git::OpenModifiedFiles",
- "menu": "editor::OpenContextMenu",
- "shift-f10": "editor::OpenContextMenu",
- "ctrl-shift-e": "editor::ToggleEditPrediction",
- "f9": "editor::ToggleBreakpoint",
- "shift-f9": "editor::EditLogBreakpoint"
- }
- },
- {
- "context": "Editor && mode == full",
- "use_key_equivalents": true,
- "bindings": {
- "shift-enter": "editor::Newline",
- "enter": "editor::Newline",
- "ctrl-enter": "editor::NewlineAbove",
- "ctrl-shift-enter": "editor::NewlineBelow",
- "ctrl-k ctrl-z": "editor::ToggleSoftWrap",
- "ctrl-k z": "editor::ToggleSoftWrap",
- "find": "buffer_search::Deploy",
- "ctrl-f": "buffer_search::Deploy",
- "ctrl-h": "buffer_search::DeployReplace",
- "ctrl-shift-.": "assistant::QuoteSelection",
- "ctrl-shift-,": "assistant::InsertIntoEditor",
- "shift-alt-e": "editor::SelectEnclosingSymbol",
- "ctrl-shift-backspace": "editor::GoToPreviousChange",
- "ctrl-shift-alt-backspace": "editor::GoToNextChange",
- "alt-enter": "editor::OpenSelectionsInMultibuffer"
- }
- },
- {
- "context": "Editor && mode == full && edit_prediction",
- "use_key_equivalents": true,
- "bindings": {
- "alt-]": "editor::NextEditPrediction",
- "alt-[": "editor::PreviousEditPrediction"
- }
- },
- {
- "context": "Editor && !edit_prediction",
- "use_key_equivalents": true,
- "bindings": {
- "alt-\\": "editor::ShowEditPrediction"
- }
- },
- {
- "context": "Editor && mode == auto_height",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-enter": "editor::Newline",
- "shift-enter": "editor::Newline",
- "ctrl-shift-enter": "editor::NewlineBelow"
- }
- },
- {
- "context": "Markdown",
- "use_key_equivalents": true,
- "bindings": {
- "copy": "markdown::Copy",
- "ctrl-c": "markdown::Copy"
- }
- },
- {
- "context": "Editor && jupyter && !ContextEditor",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-shift-enter": "repl::Run",
- "ctrl-alt-enter": "repl::RunInPlace"
- }
- },
- {
- "context": "Editor && !agent_diff",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-k ctrl-r": "git::Restore",
- "alt-y": "git::StageAndNext",
- "shift-alt-y": "git::UnstageAndNext"
- }
- },
- {
- "context": "Editor && editor_agent_diff",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-y": "agent::Keep",
- "ctrl-n": "agent::Reject",
- "ctrl-shift-y": "agent::KeepAll",
- "ctrl-shift-n": "agent::RejectAll",
- "ctrl-shift-r": "agent::OpenAgentDiff"
- }
- },
- {
- "context": "AgentDiff",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-y": "agent::Keep",
- "ctrl-n": "agent::Reject",
- "ctrl-shift-y": "agent::KeepAll",
- "ctrl-shift-n": "agent::RejectAll"
- }
- },
- {
- "context": "ContextEditor > Editor",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-enter": "assistant::Assist",
- "ctrl-s": "workspace::Save",
- "save": "workspace::Save",
- "ctrl-shift-,": "assistant::InsertIntoEditor",
- "shift-enter": "assistant::Split",
- "ctrl-r": "assistant::CycleMessageRole",
- "enter": "assistant::ConfirmCommand",
- "alt-enter": "editor::Newline",
- "ctrl-k c": "assistant::CopyCode",
- "ctrl-g": "search::SelectNextMatch",
- "ctrl-shift-g": "search::SelectPreviousMatch",
- "ctrl-k l": "agent::OpenRulesLibrary"
- }
- },
- {
- "context": "AgentPanel",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-n": "agent::NewThread",
- "shift-alt-n": "agent::NewTextThread",
- "ctrl-shift-h": "agent::OpenHistory",
- "shift-alt-c": "agent::OpenSettings",
- "shift-alt-p": "agent::OpenRulesLibrary",
- "ctrl-i": "agent::ToggleProfileSelector",
- "shift-alt-/": "agent::ToggleModelSelector",
- "ctrl-shift-a": "agent::ToggleContextPicker",
- "ctrl-shift-j": "agent::ToggleNavigationMenu",
- "ctrl-shift-i": "agent::ToggleOptionsMenu",
- // "ctrl-shift-alt-n": "agent::ToggleNewThreadMenu",
- "shift-alt-escape": "agent::ExpandMessageEditor",
- "ctrl-shift-.": "assistant::QuoteSelection",
- "shift-alt-e": "agent::RemoveAllContext",
- "ctrl-shift-e": "project_panel::ToggleFocus",
- "ctrl-shift-enter": "agent::ContinueThread",
- "super-ctrl-b": "agent::ToggleBurnMode",
- "alt-enter": "agent::ContinueWithBurnMode"
- }
- },
- {
- "context": "AgentPanel > NavigationMenu",
- "use_key_equivalents": true,
- "bindings": {
- "shift-backspace": "agent::DeleteRecentlyOpenThread"
- }
- },
- {
- "context": "AgentPanel > Markdown",
- "use_key_equivalents": true,
- "bindings": {
- "copy": "markdown::CopyAsMarkdown",
- "ctrl-c": "markdown::CopyAsMarkdown"
- }
- },
- {
- "context": "AgentPanel && prompt_editor",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-n": "agent::NewTextThread",
- "ctrl-alt-t": "agent::NewThread"
- }
- },
- {
- "context": "AgentPanel && external_agent_thread",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-n": "agent::NewExternalAgentThread",
- "ctrl-alt-t": "agent::NewThread"
- }
- },
- {
- "context": "MessageEditor && !Picker > Editor && !use_modifier_to_send",
- "use_key_equivalents": true,
- "bindings": {
- "enter": "agent::Chat",
- "ctrl-enter": "agent::ChatWithFollow",
- "ctrl-i": "agent::ToggleProfileSelector",
- "ctrl-shift-r": "agent::OpenAgentDiff",
- "ctrl-shift-y": "agent::KeepAll",
- "ctrl-shift-n": "agent::RejectAll"
- }
- },
- {
- "context": "MessageEditor && !Picker > Editor && use_modifier_to_send",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-enter": "agent::Chat",
- "enter": "editor::Newline",
- "ctrl-i": "agent::ToggleProfileSelector",
- "ctrl-shift-r": "agent::OpenAgentDiff",
- "ctrl-shift-y": "agent::KeepAll",
- "ctrl-shift-n": "agent::RejectAll"
- }
- },
- {
- "context": "EditMessageEditor > Editor",
- "use_key_equivalents": true,
- "bindings": {
- "escape": "menu::Cancel",
- "enter": "menu::Confirm",
- "alt-enter": "editor::Newline"
- }
- },
- {
- "context": "AgentFeedbackMessageEditor > Editor",
- "use_key_equivalents": true,
- "bindings": {
- "escape": "menu::Cancel",
- "enter": "menu::Confirm",
- "alt-enter": "editor::Newline"
- }
- },
- {
- "context": "ContextStrip",
- "use_key_equivalents": true,
- "bindings": {
- "up": "agent::FocusUp",
- "right": "agent::FocusRight",
- "left": "agent::FocusLeft",
- "down": "agent::FocusDown",
- "backspace": "agent::RemoveFocusedContext",
- "enter": "agent::AcceptSuggestedContext"
- }
- },
- {
- "context": "AcpThread > Editor",
- "use_key_equivalents": true,
- "bindings": {
- "enter": "agent::Chat",
- "ctrl-shift-r": "agent::OpenAgentDiff",
- "ctrl-shift-y": "agent::KeepAll",
- "ctrl-shift-n": "agent::RejectAll"
- }
- },
- {
- "context": "ThreadHistory",
- "use_key_equivalents": true,
- "bindings": {
- "backspace": "agent::RemoveSelectedThread"
- }
- },
- {
- "context": "PromptLibrary",
- "use_key_equivalents": true,
- "bindings": {
- "new": "rules_library::NewRule",
- "ctrl-n": "rules_library::NewRule",
- "ctrl-shift-s": "rules_library::ToggleDefaultRule"
- }
- },
- {
- "context": "BufferSearchBar",
- "use_key_equivalents": true,
- "bindings": {
- "escape": "buffer_search::Dismiss",
- "tab": "buffer_search::FocusEditor",
- "enter": "search::SelectNextMatch",
- "shift-enter": "search::SelectPreviousMatch",
- "alt-enter": "search::SelectAllMatches",
- "find": "search::FocusSearch",
- "ctrl-f": "search::FocusSearch",
- "ctrl-h": "search::ToggleReplace",
- "ctrl-l": "search::ToggleSelection"
- }
- },
- {
- "context": "BufferSearchBar && in_replace > Editor",
- "use_key_equivalents": true,
- "bindings": {
- "enter": "search::ReplaceNext",
- "ctrl-enter": "search::ReplaceAll"
- }
- },
- {
- "context": "BufferSearchBar && !in_replace > Editor",
- "use_key_equivalents": true,
- "bindings": {
- "up": "search::PreviousHistoryQuery",
- "down": "search::NextHistoryQuery"
- }
- },
- {
- "context": "ProjectSearchBar",
- "use_key_equivalents": true,
- "bindings": {
- "escape": "project_search::ToggleFocus",
- "shift-find": "search::FocusSearch",
- "ctrl-shift-f": "search::FocusSearch",
- "ctrl-shift-h": "search::ToggleReplace",
- "alt-r": "search::ToggleRegex" // vscode
- }
- },
- {
- "context": "ProjectSearchBar > Editor",
- "use_key_equivalents": true,
- "bindings": {
- "up": "search::PreviousHistoryQuery",
- "down": "search::NextHistoryQuery"
- }
- },
- {
- "context": "ProjectSearchBar && in_replace > Editor",
- "use_key_equivalents": true,
- "bindings": {
- "enter": "search::ReplaceNext",
- "ctrl-alt-enter": "search::ReplaceAll"
- }
- },
- {
- "context": "ProjectSearchView",
- "use_key_equivalents": true,
- "bindings": {
- "escape": "project_search::ToggleFocus",
- "ctrl-shift-h": "search::ToggleReplace",
- "alt-r": "search::ToggleRegex" // vscode
- }
- },
- {
- "context": "Pane",
- "use_key_equivalents": true,
- "bindings": {
- "alt-1": ["pane::ActivateItem", 0],
- "alt-2": ["pane::ActivateItem", 1],
- "alt-3": ["pane::ActivateItem", 2],
- "alt-4": ["pane::ActivateItem", 3],
- "alt-5": ["pane::ActivateItem", 4],
- "alt-6": ["pane::ActivateItem", 5],
- "alt-7": ["pane::ActivateItem", 6],
- "alt-8": ["pane::ActivateItem", 7],
- "alt-9": ["pane::ActivateItem", 8],
- "alt-0": "pane::ActivateLastItem",
- "ctrl-pageup": "pane::ActivatePreviousItem",
- "ctrl-pagedown": "pane::ActivateNextItem",
- "ctrl-shift-pageup": "pane::SwapItemLeft",
- "ctrl-shift-pagedown": "pane::SwapItemRight",
- "ctrl-f4": ["pane::CloseActiveItem", { "close_pinned": false }],
- "ctrl-w": ["pane::CloseActiveItem", { "close_pinned": false }],
- "ctrl-shift-alt-t": ["pane::CloseOtherItems", { "close_pinned": false }],
- "ctrl-shift-alt-w": "workspace::CloseInactiveTabsAndPanes",
- "ctrl-k e": ["pane::CloseItemsToTheLeft", { "close_pinned": false }],
- "ctrl-k t": ["pane::CloseItemsToTheRight", { "close_pinned": false }],
- "ctrl-k u": ["pane::CloseCleanItems", { "close_pinned": false }],
- "ctrl-k w": ["pane::CloseAllItems", { "close_pinned": false }],
- "ctrl-k ctrl-w": "workspace::CloseAllItemsAndPanes",
- "back": "pane::GoBack",
- "alt--": "pane::GoBack",
- "alt-=": "pane::GoForward",
- "forward": "pane::GoForward",
- "f3": "search::SelectNextMatch",
- "shift-f3": "search::SelectPreviousMatch",
- "shift-find": "project_search::ToggleFocus",
- "ctrl-shift-f": "project_search::ToggleFocus",
- "shift-alt-h": "search::ToggleReplace",
- "alt-l": "search::ToggleSelection",
- "alt-enter": "search::SelectAllMatches",
- "alt-c": "search::ToggleCaseSensitive",
- "alt-w": "search::ToggleWholeWord",
- "alt-find": "project_search::ToggleFilters",
- "alt-f": "project_search::ToggleFilters",
- "alt-r": "search::ToggleRegex",
- // "ctrl-shift-alt-x": "search::ToggleRegex",
- "ctrl-k shift-enter": "pane::TogglePinTab"
- }
- },
- // Bindings from VS Code
- {
- "context": "Editor",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-[": "editor::Outdent",
- "ctrl-]": "editor::Indent",
- "ctrl-shift-alt-up": "editor::AddSelectionAbove", // Insert Cursor Above
- "ctrl-shift-alt-down": "editor::AddSelectionBelow", // Insert Cursor Below
- "ctrl-shift-k": "editor::DeleteLine",
- "alt-up": "editor::MoveLineUp",
- "alt-down": "editor::MoveLineDown",
- "shift-alt-up": "editor::DuplicateLineUp",
- "shift-alt-down": "editor::DuplicateLineDown",
- "shift-alt-right": "editor::SelectLargerSyntaxNode", // Expand Selection
- "shift-alt-left": "editor::SelectSmallerSyntaxNode", // Shrink Selection
- "ctrl-shift-l": "editor::SelectAllMatches", // Select all occurrences of current selection
- "ctrl-f2": "editor::SelectAllMatches", // Select all occurrences of current word
- "ctrl-d": ["editor::SelectNext", { "replace_newest": false }], // editor.action.addSelectionToNextFindMatch / find_under_expand
- "ctrl-shift-down": ["editor::SelectNext", { "replace_newest": false }], // editor.action.addSelectionToNextFindMatch
- "ctrl-shift-up": ["editor::SelectPrevious", { "replace_newest": false }], // editor.action.addSelectionToPreviousFindMatch
- "ctrl-k ctrl-d": ["editor::SelectNext", { "replace_newest": true }], // editor.action.moveSelectionToNextFindMatch / find_under_expand_skip
- "ctrl-k ctrl-shift-d": ["editor::SelectPrevious", { "replace_newest": true }], // editor.action.moveSelectionToPreviousFindMatch
- "ctrl-k ctrl-i": "editor::Hover",
- "ctrl-k ctrl-b": "editor::BlameHover",
- "ctrl-/": ["editor::ToggleComments", { "advance_downwards": false }],
- "f8": ["editor::GoToDiagnostic", { "severity": { "min": "hint", "max": "error" } }],
- "shift-f8": ["editor::GoToPreviousDiagnostic", { "severity": { "min": "hint", "max": "error" } }],
- "f2": "editor::Rename",
- "f12": "editor::GoToDefinition",
- "alt-f12": "editor::GoToDefinitionSplit",
- "ctrl-shift-f10": "editor::GoToDefinitionSplit",
- "ctrl-f12": "editor::GoToImplementation",
- "shift-f12": "editor::GoToTypeDefinition",
- "ctrl-alt-f12": "editor::GoToTypeDefinitionSplit",
- "shift-alt-f12": "editor::FindAllReferences",
- "ctrl-m": "editor::MoveToEnclosingBracket", // from jetbrains
- "ctrl-shift-\\": "editor::MoveToEnclosingBracket",
- "ctrl-shift-[": "editor::Fold",
- "ctrl-shift-]": "editor::UnfoldLines",
- "ctrl-k ctrl-l": "editor::ToggleFold",
- "ctrl-k ctrl-[": "editor::FoldRecursive",
- "ctrl-k ctrl-]": "editor::UnfoldRecursive",
- "ctrl-k ctrl-1": ["editor::FoldAtLevel", 1],
- "ctrl-k ctrl-2": ["editor::FoldAtLevel", 2],
- "ctrl-k ctrl-3": ["editor::FoldAtLevel", 3],
- "ctrl-k ctrl-4": ["editor::FoldAtLevel", 4],
- "ctrl-k ctrl-5": ["editor::FoldAtLevel", 5],
- "ctrl-k ctrl-6": ["editor::FoldAtLevel", 6],
- "ctrl-k ctrl-7": ["editor::FoldAtLevel", 7],
- "ctrl-k ctrl-8": ["editor::FoldAtLevel", 8],
- "ctrl-k ctrl-9": ["editor::FoldAtLevel", 9],
- "ctrl-k ctrl-0": "editor::FoldAll",
- "ctrl-k ctrl-j": "editor::UnfoldAll",
- "ctrl-space": "editor::ShowCompletions",
- "ctrl-shift-space": "editor::ShowWordCompletions",
- "ctrl-.": "editor::ToggleCodeActions",
- "ctrl-k r": "editor::RevealInFileManager",
- "ctrl-k p": "editor::CopyPath",
- "ctrl-\\": "pane::SplitRight",
- "ctrl-shift-alt-c": "editor::DisplayCursorNames",
- "alt-.": "editor::GoToHunk",
- "alt-,": "editor::GoToPreviousHunk"
- }
- },
- {
- "context": "Editor && extension == md",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-k v": "markdown::OpenPreviewToTheSide",
- "ctrl-shift-v": "markdown::OpenPreview"
- }
- },
- {
- "context": "Editor && extension == svg",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-k v": "svg::OpenPreviewToTheSide",
- "ctrl-shift-v": "svg::OpenPreview"
- }
- },
- {
- "context": "Editor && mode == full",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-shift-o": "outline::Toggle",
- "ctrl-g": "go_to_line::Toggle"
- }
- },
- {
- "context": "Workspace",
- "use_key_equivalents": true,
- "bindings": {
- "alt-open": ["projects::OpenRecent", { "create_new_window": false }],
- // Change the default action on `menu::Confirm` by setting the parameter
- // "ctrl-alt-o": ["projects::OpenRecent", { "create_new_window": true }],
- "ctrl-r": ["projects::OpenRecent", { "create_new_window": false }],
- "shift-alt-open": ["projects::OpenRemote", { "from_existing_connection": false, "create_new_window": false }],
- // Change to open path modal for existing remote connection by setting the parameter
- // "ctrl-shift-alt-o": "["projects::OpenRemote", { "from_existing_connection": true }]",
- "ctrl-shift-alt-o": ["projects::OpenRemote", { "from_existing_connection": false, "create_new_window": false }],
- "shift-alt-b": "branches::OpenRecent",
- "shift-alt-enter": "toast::RunAction",
- "ctrl-shift-`": "workspace::NewTerminal",
- "save": "workspace::Save",
- "ctrl-s": "workspace::Save",
- "ctrl-k ctrl-shift-s": "workspace::SaveWithoutFormat",
- "shift-save": "workspace::SaveAs",
- "ctrl-shift-s": "workspace::SaveAs",
- "new": "workspace::NewFile",
- "ctrl-n": "workspace::NewFile",
- "shift-new": "workspace::NewWindow",
- "ctrl-shift-n": "workspace::NewWindow",
- "ctrl-`": "terminal_panel::ToggleFocus",
- "f10": ["app_menu::OpenApplicationMenu", "Zed"],
- "alt-1": ["workspace::ActivatePane", 0],
- "alt-2": ["workspace::ActivatePane", 1],
- "alt-3": ["workspace::ActivatePane", 2],
- "alt-4": ["workspace::ActivatePane", 3],
- "alt-5": ["workspace::ActivatePane", 4],
- "alt-6": ["workspace::ActivatePane", 5],
- "alt-7": ["workspace::ActivatePane", 6],
- "alt-8": ["workspace::ActivatePane", 7],
- "alt-9": ["workspace::ActivatePane", 8],
- "ctrl-alt-b": "workspace::ToggleRightDock",
- "ctrl-b": "workspace::ToggleLeftDock",
- "ctrl-j": "workspace::ToggleBottomDock",
- "ctrl-shift-y": "workspace::CloseAllDocks",
- "alt-r": "workspace::ResetActiveDockSize",
- // For 0px parameter, uses UI font size value.
- "shift-alt--": ["workspace::DecreaseActiveDockSize", { "px": 0 }],
- "shift-alt-=": ["workspace::IncreaseActiveDockSize", { "px": 0 }],
- "shift-alt-0": "workspace::ResetOpenDocksSize",
- "ctrl-shift-alt--": ["workspace::DecreaseOpenDocksSize", { "px": 0 }],
- "ctrl-shift-alt-=": ["workspace::IncreaseOpenDocksSize", { "px": 0 }],
- "shift-find": "pane::DeploySearch",
- "ctrl-shift-f": "pane::DeploySearch",
- "ctrl-shift-h": ["pane::DeploySearch", { "replace_enabled": true }],
- "ctrl-shift-t": "pane::ReopenClosedItem",
- "ctrl-k ctrl-s": "zed::OpenKeymapEditor",
- "ctrl-k ctrl-t": "theme_selector::Toggle",
- "ctrl-alt-super-p": "settings_profile_selector::Toggle",
- "ctrl-t": "project_symbols::Toggle",
- "ctrl-p": "file_finder::Toggle",
- "ctrl-tab": "tab_switcher::Toggle",
- "ctrl-shift-tab": ["tab_switcher::Toggle", { "select_last": true }],
- "ctrl-e": "file_finder::Toggle",
- "f1": "command_palette::Toggle",
- "ctrl-shift-p": "command_palette::Toggle",
- "ctrl-shift-m": "diagnostics::Deploy",
- "ctrl-shift-e": "project_panel::ToggleFocus",
- "ctrl-shift-b": "outline_panel::ToggleFocus",
- "ctrl-shift-g": "git_panel::ToggleFocus",
- "ctrl-shift-d": "debug_panel::ToggleFocus",
- "ctrl-shift-/": "agent::ToggleFocus",
- "alt-save": "workspace::SaveAll",
- "ctrl-k s": "workspace::SaveAll",
- "ctrl-k m": "language_selector::Toggle",
- "escape": "workspace::Unfollow",
- "ctrl-k ctrl-left": "workspace::ActivatePaneLeft",
- "ctrl-k ctrl-right": "workspace::ActivatePaneRight",
- "ctrl-k ctrl-up": "workspace::ActivatePaneUp",
- "ctrl-k ctrl-down": "workspace::ActivatePaneDown",
- "ctrl-k shift-left": "workspace::SwapPaneLeft",
- "ctrl-k shift-right": "workspace::SwapPaneRight",
- "ctrl-k shift-up": "workspace::SwapPaneUp",
- "ctrl-k shift-down": "workspace::SwapPaneDown",
- "ctrl-shift-x": "zed::Extensions",
- "ctrl-shift-r": "task::Rerun",
- "alt-t": "task::Rerun",
- "shift-alt-t": "task::Spawn",
- "shift-alt-r": ["task::Spawn", { "reveal_target": "center" }],
- // also possible to spawn tasks by name:
- // "foo-bar": ["task::Spawn", { "task_name": "MyTask", "reveal_target": "dock" }]
- // or by tag:
- // "foo-bar": ["task::Spawn", { "task_tag": "MyTag" }],
- "f5": "debugger::Rerun",
- "ctrl-f4": "workspace::CloseActiveDock",
- "ctrl-w": "workspace::CloseActiveDock"
- }
- },
- {
- "context": "Workspace && debugger_running",
- "use_key_equivalents": true,
- "bindings": {
- "f5": "zed::NoAction"
- }
- },
- {
- "context": "Workspace && debugger_stopped",
- "use_key_equivalents": true,
- "bindings": {
- "f5": "debugger::Continue"
- }
- },
- {
- "context": "ApplicationMenu",
- "use_key_equivalents": true,
- "bindings": {
- "f10": "menu::Cancel",
- "left": "app_menu::ActivateMenuLeft",
- "right": "app_menu::ActivateMenuRight"
- }
- },
- // Bindings from Sublime Text
- {
- "context": "Editor",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-u": "editor::UndoSelection",
- "ctrl-shift-u": "editor::RedoSelection",
- "ctrl-shift-j": "editor::JoinLines",
- "ctrl-alt-backspace": "editor::DeleteToPreviousSubwordStart",
- "shift-alt-h": "editor::DeleteToPreviousSubwordStart",
- "ctrl-alt-delete": "editor::DeleteToNextSubwordEnd",
- "shift-alt-d": "editor::DeleteToNextSubwordEnd",
- "ctrl-alt-left": "editor::MoveToPreviousSubwordStart",
- "ctrl-alt-right": "editor::MoveToNextSubwordEnd",
- "ctrl-shift-alt-left": "editor::SelectToPreviousSubwordStart",
- "ctrl-shift-alt-right": "editor::SelectToNextSubwordEnd"
- }
- },
- // Bindings from Atom
- {
- "context": "Pane",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-k up": "pane::SplitUp",
- "ctrl-k down": "pane::SplitDown",
- "ctrl-k left": "pane::SplitLeft",
- "ctrl-k right": "pane::SplitRight"
- }
- },
- // Bindings that should be unified with bindings for more general actions
- {
- "context": "Editor && renaming",
- "use_key_equivalents": true,
- "bindings": {
- "enter": "editor::ConfirmRename"
- }
- },
- {
- "context": "Editor && showing_completions",
- "use_key_equivalents": true,
- "bindings": {
- "enter": "editor::ConfirmCompletion",
- "shift-enter": "editor::ConfirmCompletionReplace",
- "tab": "editor::ComposeCompletion"
- }
- },
- // Bindings for accepting edit predictions
- //
- // alt-l is provided as an alternative to tab/alt-tab. and will be displayed in the UI. This is
- // because alt-tab may not be available, as it is often used for window switching.
- {
- "context": "Editor && edit_prediction",
- "use_key_equivalents": true,
- "bindings": {
- "alt-tab": "editor::AcceptEditPrediction",
- "alt-l": "editor::AcceptEditPrediction",
- "tab": "editor::AcceptEditPrediction",
- "alt-right": "editor::AcceptPartialEditPrediction"
- }
- },
- {
- "context": "Editor && edit_prediction_conflict",
- "use_key_equivalents": true,
- "bindings": {
- "alt-tab": "editor::AcceptEditPrediction",
- "alt-l": "editor::AcceptEditPrediction",
- "alt-right": "editor::AcceptPartialEditPrediction"
- }
- },
- {
- "context": "Editor && showing_code_actions",
- "use_key_equivalents": true,
- "bindings": {
- "enter": "editor::ConfirmCodeAction"
- }
- },
- {
- "context": "Editor && (showing_code_actions || showing_completions)",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-p": "editor::ContextMenuPrevious",
- "up": "editor::ContextMenuPrevious",
- "ctrl-n": "editor::ContextMenuNext",
- "down": "editor::ContextMenuNext",
- "pageup": "editor::ContextMenuFirst",
- "pagedown": "editor::ContextMenuLast"
- }
- },
- {
- "context": "Editor && showing_signature_help && !showing_completions",
- "use_key_equivalents": true,
- "bindings": {
- "up": "editor::SignatureHelpPrevious",
- "down": "editor::SignatureHelpNext"
- }
- },
- // Custom bindings
- {
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-shift-alt-f": "workspace::FollowNextCollaborator",
- // Only available in debug builds: opens an element inspector for development.
- "shift-alt-i": "dev::ToggleInspector"
- }
- },
- {
- "context": "!Terminal",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-shift-c": "collab_panel::ToggleFocus"
- }
- },
- {
- "context": "!ContextEditor > Editor && mode == full",
- "use_key_equivalents": true,
- "bindings": {
- "alt-enter": "editor::OpenExcerpts",
- "shift-enter": "editor::ExpandExcerpts",
- "ctrl-alt-enter": "editor::OpenExcerptsSplit",
- "ctrl-shift-e": "pane::RevealInProjectPanel",
- "ctrl-f8": "editor::GoToHunk",
- "ctrl-shift-f8": "editor::GoToPreviousHunk",
- "ctrl-enter": "assistant::InlineAssist",
- "ctrl-shift-;": "editor::ToggleInlayHints"
- }
- },
- {
- "context": "PromptEditor",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-[": "agent::CyclePreviousInlineAssist",
- "ctrl-]": "agent::CycleNextInlineAssist",
- "shift-alt-e": "agent::RemoveAllContext"
- }
- },
- {
- "context": "Prompt",
- "use_key_equivalents": true,
- "bindings": {
- "left": "menu::SelectPrevious",
- "right": "menu::SelectNext",
- "h": "menu::SelectPrevious",
- "l": "menu::SelectNext"
- }
- },
- {
- "context": "ProjectSearchBar && !in_replace",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-enter": "project_search::SearchInNew"
- }
- },
- {
- "context": "OutlinePanel && not_editing",
- "use_key_equivalents": true,
- "bindings": {
- "left": "outline_panel::CollapseSelectedEntry",
- "right": "outline_panel::ExpandSelectedEntry",
- "alt-copy": "outline_panel::CopyPath",
- "shift-alt-c": "outline_panel::CopyPath",
- "shift-alt-copy": "workspace::CopyRelativePath",
- "ctrl-shift-alt-c": "workspace::CopyRelativePath",
- "ctrl-alt-r": "outline_panel::RevealInFileManager",
- "space": "outline_panel::OpenSelectedEntry",
- "shift-down": "menu::SelectNext",
- "shift-up": "menu::SelectPrevious",
- "alt-enter": "editor::OpenExcerpts",
- "ctrl-alt-enter": "editor::OpenExcerptsSplit"
- }
- },
- {
- "context": "ProjectPanel",
- "use_key_equivalents": true,
- "bindings": {
- "left": "project_panel::CollapseSelectedEntry",
- "right": "project_panel::ExpandSelectedEntry",
- "new": "project_panel::NewFile",
- "ctrl-n": "project_panel::NewFile",
- "alt-new": "project_panel::NewDirectory",
- "alt-n": "project_panel::NewDirectory",
- "cut": "project_panel::Cut",
- "ctrl-x": "project_panel::Cut",
- "copy": "project_panel::Copy",
- "ctrl-insert": "project_panel::Copy",
- "ctrl-c": "project_panel::Copy",
- "paste": "project_panel::Paste",
- "shift-insert": "project_panel::Paste",
- "ctrl-v": "project_panel::Paste",
- "alt-copy": "project_panel::CopyPath",
- "shift-alt-c": "project_panel::CopyPath",
- "shift-alt-copy": "workspace::CopyRelativePath",
- "ctrl-k ctrl-shift-c": "workspace::CopyRelativePath",
- "enter": "project_panel::Rename",
- "f2": "project_panel::Rename",
- "backspace": ["project_panel::Trash", { "skip_prompt": false }],
- "delete": ["project_panel::Trash", { "skip_prompt": false }],
- "shift-delete": ["project_panel::Delete", { "skip_prompt": false }],
- "ctrl-backspace": ["project_panel::Delete", { "skip_prompt": false }],
- "ctrl-delete": ["project_panel::Delete", { "skip_prompt": false }],
- "ctrl-alt-r": "project_panel::RevealInFileManager",
- "ctrl-shift-enter": "project_panel::OpenWithSystem",
- "alt-d": "project_panel::CompareMarkedFiles",
- "shift-find": "project_panel::NewSearchInDirectory",
- "ctrl-k ctrl-shift-f": "project_panel::NewSearchInDirectory",
- "shift-down": "menu::SelectNext",
- "shift-up": "menu::SelectPrevious",
- "escape": "menu::Cancel"
- }
- },
- {
- "context": "ProjectPanel && not_editing",
- "use_key_equivalents": true,
- "bindings": {
- "space": "project_panel::Open"
- }
- },
- {
- "context": "GitPanel && ChangesList",
- "use_key_equivalents": true,
- "bindings": {
- "up": "menu::SelectPrevious",
- "down": "menu::SelectNext",
- "enter": "menu::Confirm",
- "alt-y": "git::StageFile",
- "shift-alt-y": "git::UnstageFile",
- "space": "git::ToggleStaged",
- "shift-space": "git::StageRange",
- "tab": "git_panel::FocusEditor",
- "shift-tab": "git_panel::FocusEditor",
- "escape": "git_panel::ToggleFocus",
- "alt-enter": "menu::SecondaryConfirm",
- "delete": ["git::RestoreFile", { "skip_prompt": false }],
- "backspace": ["git::RestoreFile", { "skip_prompt": false }],
- "shift-delete": ["git::RestoreFile", { "skip_prompt": false }],
- "ctrl-backspace": ["git::RestoreFile", { "skip_prompt": false }],
- "ctrl-delete": ["git::RestoreFile", { "skip_prompt": false }]
- }
- },
- {
- "context": "GitPanel && CommitEditor",
- "use_key_equivalents": true,
- "bindings": {
- "escape": "git::Cancel"
- }
- },
- {
- "context": "GitCommit > Editor",
- "use_key_equivalents": true,
- "bindings": {
- "escape": "menu::Cancel",
- "enter": "editor::Newline",
- "ctrl-enter": "git::Commit",
- "ctrl-shift-enter": "git::Amend",
- "alt-l": "git::GenerateCommitMessage"
- }
- },
- {
- "context": "GitPanel",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-g ctrl-g": "git::Fetch",
- "ctrl-g up": "git::Push",
- "ctrl-g down": "git::Pull",
- "ctrl-g shift-up": "git::ForcePush",
- "ctrl-g d": "git::Diff",
- "ctrl-g backspace": "git::RestoreTrackedFiles",
- "ctrl-g shift-backspace": "git::TrashUntrackedFiles",
- "ctrl-space": "git::StageAll",
- "ctrl-shift-space": "git::UnstageAll",
- "ctrl-enter": "git::Commit",
- "ctrl-shift-enter": "git::Amend"
- }
- },
- {
- "context": "GitDiff > Editor",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-enter": "git::Commit",
- "ctrl-shift-enter": "git::Amend",
- "ctrl-space": "git::StageAll",
- "ctrl-shift-space": "git::UnstageAll"
- }
- },
- {
- "context": "AskPass > Editor",
- "use_key_equivalents": true,
- "bindings": {
- "enter": "menu::Confirm"
- }
- },
- {
- "context": "CommitEditor > Editor",
- "use_key_equivalents": true,
- "bindings": {
- "escape": "git_panel::FocusChanges",
- "tab": "git_panel::FocusChanges",
- "shift-tab": "git_panel::FocusChanges",
- "enter": "editor::Newline",
- "ctrl-enter": "git::Commit",
- "ctrl-shift-enter": "git::Amend",
- "alt-up": "git_panel::FocusChanges",
- "alt-l": "git::GenerateCommitMessage"
- }
- },
- {
- "context": "DebugPanel",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-t": "debugger::ToggleThreadPicker",
- "ctrl-i": "debugger::ToggleSessionPicker",
- "shift-alt-escape": "debugger::ToggleExpandItem"
- }
- },
- {
- "context": "VariableList",
- "use_key_equivalents": true,
- "bindings": {
- "left": "variable_list::CollapseSelectedEntry",
- "right": "variable_list::ExpandSelectedEntry",
- "enter": "variable_list::EditVariable",
- "ctrl-c": "variable_list::CopyVariableValue",
- "ctrl-alt-c": "variable_list::CopyVariableName",
- "delete": "variable_list::RemoveWatch",
- "backspace": "variable_list::RemoveWatch",
- "alt-enter": "variable_list::AddWatch"
- }
- },
- {
- "context": "BreakpointList",
- "use_key_equivalents": true,
- "bindings": {
- "space": "debugger::ToggleEnableBreakpoint",
- "backspace": "debugger::UnsetBreakpoint",
- "left": "debugger::PreviousBreakpointProperty",
- "right": "debugger::NextBreakpointProperty"
- }
- },
- {
- "context": "CollabPanel && not_editing",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-backspace": "collab_panel::Remove",
- "space": "menu::Confirm"
- }
- },
- {
- "context": "CollabPanel",
- "use_key_equivalents": true,
- "bindings": {
- "alt-up": "collab_panel::MoveChannelUp",
- "alt-down": "collab_panel::MoveChannelDown"
- }
- },
- {
- "context": "(CollabPanel && editing) > Editor",
- "use_key_equivalents": true,
- "bindings": {
- "space": "collab_panel::InsertSpace"
- }
- },
- {
- "context": "ChannelModal",
- "use_key_equivalents": true,
- "bindings": {
- "tab": "channel_modal::ToggleMode"
- }
- },
- {
- "context": "Picker > Editor",
- "use_key_equivalents": true,
- "bindings": {
- "escape": "menu::Cancel",
- "up": "menu::SelectPrevious",
- "down": "menu::SelectNext",
- "tab": "picker::ConfirmCompletion",
- "alt-enter": ["picker::ConfirmInput", { "secondary": false }]
- }
- },
- {
- "context": "ChannelModal > Picker > Editor",
- "use_key_equivalents": true,
- "bindings": {
- "tab": "channel_modal::ToggleMode"
- }
- },
- {
- "context": "FileFinder || (FileFinder > Picker > Editor)",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-p": "file_finder::Toggle",
- "ctrl-shift-a": "file_finder::ToggleSplitMenu",
- "ctrl-shift-i": "file_finder::ToggleFilterMenu"
- }
- },
- {
- "context": "FileFinder || (FileFinder > Picker > Editor) || (FileFinder > Picker > menu)",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-shift-p": "file_finder::SelectPrevious",
- "ctrl-j": "pane::SplitDown",
- "ctrl-k": "pane::SplitUp",
- "ctrl-h": "pane::SplitLeft",
- "ctrl-l": "pane::SplitRight"
- }
- },
- {
- "context": "TabSwitcher",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-shift-tab": "menu::SelectPrevious",
- "ctrl-up": "menu::SelectPrevious",
- "ctrl-down": "menu::SelectNext",
- "ctrl-backspace": "tab_switcher::CloseSelectedItem"
- }
- },
- {
- "context": "Terminal",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-alt-space": "terminal::ShowCharacterPalette",
- "copy": "terminal::Copy",
- "ctrl-insert": "terminal::Copy",
- "ctrl-shift-c": "terminal::Copy",
- "paste": "terminal::Paste",
- "shift-insert": "terminal::Paste",
- "ctrl-shift-v": "terminal::Paste",
- "ctrl-enter": "assistant::InlineAssist",
- "alt-b": ["terminal::SendText", "\u001bb"],
- "alt-f": ["terminal::SendText", "\u001bf"],
- "alt-.": ["terminal::SendText", "\u001b."],
- "ctrl-delete": ["terminal::SendText", "\u001bd"],
- // Overrides for conflicting keybindings
- "ctrl-b": ["terminal::SendKeystroke", "ctrl-b"],
- "ctrl-c": ["terminal::SendKeystroke", "ctrl-c"],
- "ctrl-e": ["terminal::SendKeystroke", "ctrl-e"],
- "ctrl-o": ["terminal::SendKeystroke", "ctrl-o"],
- "ctrl-w": ["terminal::SendKeystroke", "ctrl-w"],
- "ctrl-backspace": ["terminal::SendKeystroke", "ctrl-w"],
- "ctrl-shift-a": "editor::SelectAll",
- "find": "buffer_search::Deploy",
- "ctrl-shift-f": "buffer_search::Deploy",
- "ctrl-shift-l": "terminal::Clear",
- "ctrl-shift-w": "pane::CloseActiveItem",
- "up": ["terminal::SendKeystroke", "up"],
- "pageup": ["terminal::SendKeystroke", "pageup"],
- "down": ["terminal::SendKeystroke", "down"],
- "pagedown": ["terminal::SendKeystroke", "pagedown"],
- "escape": ["terminal::SendKeystroke", "escape"],
- "enter": ["terminal::SendKeystroke", "enter"],
- "shift-pageup": "terminal::ScrollPageUp",
- "shift-pagedown": "terminal::ScrollPageDown",
- "shift-up": "terminal::ScrollLineUp",
- "shift-down": "terminal::ScrollLineDown",
- "shift-home": "terminal::ScrollToTop",
- "shift-end": "terminal::ScrollToBottom",
- "ctrl-shift-space": "terminal::ToggleViMode",
- "ctrl-shift-r": "terminal::RerunTask",
- "ctrl-alt-r": "terminal::RerunTask",
- "alt-t": "terminal::RerunTask"
- }
- },
- {
- "context": "ZedPredictModal",
- "use_key_equivalents": true,
- "bindings": {
- "escape": "menu::Cancel"
- }
- },
- {
- "context": "ConfigureContextServerModal > Editor",
- "use_key_equivalents": true,
- "bindings": {
- "escape": "menu::Cancel",
- "enter": "editor::Newline",
- "ctrl-enter": "menu::Confirm"
- }
- },
- {
- "context": "OnboardingAiConfigurationModal",
- "use_key_equivalents": true,
- "bindings": {
- "escape": "menu::Cancel"
- }
- },
- {
- "context": "Diagnostics",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-r": "diagnostics::ToggleDiagnosticsRefresh"
- }
- },
- {
- "context": "DebugConsole > Editor",
- "use_key_equivalents": true,
- "bindings": {
- "enter": "menu::Confirm",
- "alt-enter": "console::WatchExpression"
- }
- },
- {
- "context": "RunModal",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-tab": "pane::ActivateNextItem",
- "ctrl-shift-tab": "pane::ActivatePreviousItem"
- }
- },
- {
- "context": "MarkdownPreview",
- "use_key_equivalents": true,
- "bindings": {
- "pageup": "markdown::MovePageUp",
- "pagedown": "markdown::MovePageDown"
- }
- },
- {
- "context": "KeymapEditor",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-f": "search::FocusSearch",
- "alt-find": "keymap_editor::ToggleKeystrokeSearch",
- "alt-f": "keymap_editor::ToggleKeystrokeSearch",
- "alt-c": "keymap_editor::ToggleConflictFilter",
- "enter": "keymap_editor::EditBinding",
- "alt-enter": "keymap_editor::CreateBinding",
- "ctrl-c": "keymap_editor::CopyAction",
- "ctrl-shift-c": "keymap_editor::CopyContext",
- "ctrl-t": "keymap_editor::ShowMatchingKeybinds"
- }
- },
- {
- "context": "KeystrokeInput",
- "use_key_equivalents": true,
- "bindings": {
- "enter": "keystroke_input::StartRecording",
- "escape escape escape": "keystroke_input::StopRecording",
- "delete": "keystroke_input::ClearKeystrokes"
- }
- },
- {
- "context": "KeybindEditorModal",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-enter": "menu::Confirm",
- "escape": "menu::Cancel"
- }
- },
- {
- "context": "KeybindEditorModal > Editor",
- "use_key_equivalents": true,
- "bindings": {
- "up": "menu::SelectPrevious",
- "down": "menu::SelectNext"
- }
- },
- {
- "context": "Onboarding",
- "use_key_equivalents": true,
- "bindings": {
- "ctrl-1": "onboarding::ActivateBasicsPage",
- "ctrl-2": "onboarding::ActivateEditingPage",
- "ctrl-3": "onboarding::ActivateAISetupPage",
- "ctrl-escape": "onboarding::Finish",
- "alt-tab": "onboarding::SignIn",
- "shift-alt-a": "onboarding::OpenAccount"
- }
- }
-]
diff --git a/assets/keymaps/linux/emacs.json b/assets/keymaps/linux/emacs.json
index 62910e297b..0ff3796f03 100755
--- a/assets/keymaps/linux/emacs.json
+++ b/assets/keymaps/linux/emacs.json
@@ -38,7 +38,6 @@
"alt-;": ["editor::ToggleComments", { "advance_downwards": false }],
"ctrl-x ctrl-;": "editor::ToggleComments",
"alt-.": "editor::GoToDefinition", // xref-find-definitions
- "alt-?": "editor::FindAllReferences", // xref-find-references
"alt-,": "pane::GoBack", // xref-pop-marker-stack
"ctrl-x h": "editor::SelectAll", // mark-whole-buffer
"ctrl-d": "editor::Delete", // delete-char
diff --git a/assets/keymaps/macos/emacs.json b/assets/keymaps/macos/emacs.json
index 62910e297b..0ff3796f03 100755
--- a/assets/keymaps/macos/emacs.json
+++ b/assets/keymaps/macos/emacs.json
@@ -38,7 +38,6 @@
"alt-;": ["editor::ToggleComments", { "advance_downwards": false }],
"ctrl-x ctrl-;": "editor::ToggleComments",
"alt-.": "editor::GoToDefinition", // xref-find-definitions
- "alt-?": "editor::FindAllReferences", // xref-find-references
"alt-,": "pane::GoBack", // xref-pop-marker-stack
"ctrl-x h": "editor::SelectAll", // mark-whole-buffer
"ctrl-d": "editor::Delete", // delete-char
diff --git a/assets/keymaps/vim.json b/assets/keymaps/vim.json
index 67add61bd3..be6d34a134 100644
--- a/assets/keymaps/vim.json
+++ b/assets/keymaps/vim.json
@@ -428,13 +428,11 @@
"g h": "vim::StartOfLine",
"g s": "vim::FirstNonWhitespace", // "g s" default behavior is "space s"
"g e": "vim::EndOfDocument",
- "g .": "vim::HelixGotoLastModification", // go to last modification
"g r": "editor::FindAllReferences", // zed specific
"g t": "vim::WindowTop",
"g c": "vim::WindowMiddle",
"g b": "vim::WindowBottom",
- "shift-r": "editor::Paste",
"x": "editor::SelectLine",
"shift-x": "editor::SelectLine",
"%": "editor::SelectAll",
@@ -821,7 +819,7 @@
"v": "project_panel::OpenPermanent",
"p": "project_panel::Open",
"x": "project_panel::RevealInFileManager",
- "s": "workspace::OpenWithSystem",
+ "s": "project_panel::OpenWithSystem",
"z d": "project_panel::CompareMarkedFiles",
"] c": "project_panel::SelectNextGitEntry",
"[ c": "project_panel::SelectPrevGitEntry",
diff --git a/assets/settings/default.json b/assets/settings/default.json
index 804198090f..c290baf003 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -162,12 +162,6 @@
// 2. Always quit the application
// "on_last_window_closed": "quit_app",
"on_last_window_closed": "platform_default",
- // Whether to show padding for zoomed panels.
- // When enabled, zoomed center panels (e.g. code editor) will have padding all around,
- // while zoomed bottom/left/right panels will have padding to the top/right/left (respectively).
- //
- // Default: true
- "zoomed_padding": true,
// Whether to use the system provided dialogs for Open and Save As.
// When set to false, Zed will use the built-in keyboard-first pickers.
"use_system_path_prompts": true,
@@ -653,8 +647,6 @@
// "never"
"show": "always"
},
- // Whether to enable drag-and-drop operations in the project panel.
- "drag_and_drop": true,
// Whether to hide the root entry when only one folder is open in the window.
"hide_root": false
},
@@ -1141,6 +1133,11 @@
// The minimum severity of the diagnostics to show inline.
// Inherits editor's diagnostics' max severity settings when `null`.
"max_severity": null
+ },
+ "cargo": {
+ // When enabled, Zed disables rust-analyzer's check on save and starts to query
+ // Cargo diagnostics separately.
+ "fetch_cargo_diagnostics": false
}
},
// Files or globs of files that will be excluded by Zed entirely. They will be skipped during file
@@ -1506,11 +1503,6 @@
//
// Default: fallback
"words": "fallback",
- // Minimum number of characters required to automatically trigger word-based completions.
- // Before that value, it's still possible to trigger the words-based completion manually with the corresponding editor command.
- //
- // Default: 3
- "words_min_length": 3,
// Whether to fetch LSP completions or not.
//
// Default: true
@@ -1637,9 +1629,6 @@
"allowed": true
}
},
- "Kotlin": {
- "language_servers": ["kotlin-language-server", "!kotlin-lsp", "..."]
- },
"LaTeX": {
"formatter": "language_server",
"language_servers": ["texlab", "..."],
@@ -1653,6 +1642,9 @@
"use_on_type_format": false,
"allow_rewrap": "anywhere",
"soft_wrap": "editor_width",
+ "completions": {
+ "words": "disabled"
+ },
"prettier": {
"allowed": true
}
@@ -1666,6 +1658,9 @@
}
},
"Plain Text": {
+ "completions": {
+ "words": "disabled"
+ },
"allow_rewrap": "anywhere"
},
"Python": {
diff --git a/assets/settings/initial_tasks.json b/assets/settings/initial_tasks.json
index 5cead67b6d..a79c550671 100644
--- a/assets/settings/initial_tasks.json
+++ b/assets/settings/initial_tasks.json
@@ -43,8 +43,8 @@
// "args": ["--login"]
// }
// }
- "shell": "system"
+ "shell": "system",
// Represents the tags for inline runnable indicators, or spawning multiple tasks at once.
- // "tags": []
+ "tags": []
}
]
diff --git a/assets/themes/ayu/ayu.json b/assets/themes/ayu/ayu.json
index 0ffbb9f61e..f9f8720729 100644
--- a/assets/themes/ayu/ayu.json
+++ b/assets/themes/ayu/ayu.json
@@ -93,7 +93,7 @@
"terminal.ansi.bright_cyan": "#4c806fff",
"terminal.ansi.dim_cyan": "#cbf2e4ff",
"terminal.ansi.white": "#bfbdb6ff",
- "terminal.ansi.bright_white": "#fafafaff",
+ "terminal.ansi.bright_white": "#bfbdb6ff",
"terminal.ansi.dim_white": "#787876ff",
"link_text.hover": "#5ac1feff",
"conflict": "#feb454ff",
@@ -479,7 +479,7 @@
"terminal.ansi.bright_cyan": "#ace0cbff",
"terminal.ansi.dim_cyan": "#2a5f4aff",
"terminal.ansi.white": "#fcfcfcff",
- "terminal.ansi.bright_white": "#ffffffff",
+ "terminal.ansi.bright_white": "#fcfcfcff",
"terminal.ansi.dim_white": "#bcbec0ff",
"link_text.hover": "#3b9ee5ff",
"conflict": "#f1ad49ff",
@@ -865,7 +865,7 @@
"terminal.ansi.bright_cyan": "#4c806fff",
"terminal.ansi.dim_cyan": "#cbf2e4ff",
"terminal.ansi.white": "#cccac2ff",
- "terminal.ansi.bright_white": "#fafafaff",
+ "terminal.ansi.bright_white": "#cccac2ff",
"terminal.ansi.dim_white": "#898a8aff",
"link_text.hover": "#72cffeff",
"conflict": "#fecf72ff",
diff --git a/assets/themes/gruvbox/gruvbox.json b/assets/themes/gruvbox/gruvbox.json
index f0f0358b76..459825c733 100644
--- a/assets/themes/gruvbox/gruvbox.json
+++ b/assets/themes/gruvbox/gruvbox.json
@@ -94,7 +94,7 @@
"terminal.ansi.bright_cyan": "#45603eff",
"terminal.ansi.dim_cyan": "#c7dfbdff",
"terminal.ansi.white": "#fbf1c7ff",
- "terminal.ansi.bright_white": "#ffffffff",
+ "terminal.ansi.bright_white": "#fbf1c7ff",
"terminal.ansi.dim_white": "#b0a189ff",
"link_text.hover": "#83a598ff",
"version_control.added": "#b7bb26ff",
@@ -494,7 +494,7 @@
"terminal.ansi.bright_cyan": "#45603eff",
"terminal.ansi.dim_cyan": "#c7dfbdff",
"terminal.ansi.white": "#fbf1c7ff",
- "terminal.ansi.bright_white": "#ffffffff",
+ "terminal.ansi.bright_white": "#fbf1c7ff",
"terminal.ansi.dim_white": "#b0a189ff",
"link_text.hover": "#83a598ff",
"version_control.added": "#b7bb26ff",
@@ -894,7 +894,7 @@
"terminal.ansi.bright_cyan": "#45603eff",
"terminal.ansi.dim_cyan": "#c7dfbdff",
"terminal.ansi.white": "#fbf1c7ff",
- "terminal.ansi.bright_white": "#ffffffff",
+ "terminal.ansi.bright_white": "#fbf1c7ff",
"terminal.ansi.dim_white": "#b0a189ff",
"link_text.hover": "#83a598ff",
"version_control.added": "#b7bb26ff",
@@ -1294,7 +1294,7 @@
"terminal.ansi.bright_cyan": "#9fbca8ff",
"terminal.ansi.dim_cyan": "#253e2eff",
"terminal.ansi.white": "#fbf1c7ff",
- "terminal.ansi.bright_white": "#ffffffff",
+ "terminal.ansi.bright_white": "#fbf1c7ff",
"terminal.ansi.dim_white": "#b0a189ff",
"link_text.hover": "#0b6678ff",
"version_control.added": "#797410ff",
@@ -1694,7 +1694,7 @@
"terminal.ansi.bright_cyan": "#9fbca8ff",
"terminal.ansi.dim_cyan": "#253e2eff",
"terminal.ansi.white": "#f9f5d7ff",
- "terminal.ansi.bright_white": "#ffffffff",
+ "terminal.ansi.bright_white": "#f9f5d7ff",
"terminal.ansi.dim_white": "#b0a189ff",
"link_text.hover": "#0b6678ff",
"version_control.added": "#797410ff",
@@ -2094,7 +2094,7 @@
"terminal.ansi.bright_cyan": "#9fbca8ff",
"terminal.ansi.dim_cyan": "#253e2eff",
"terminal.ansi.white": "#f2e5bcff",
- "terminal.ansi.bright_white": "#ffffffff",
+ "terminal.ansi.bright_white": "#f2e5bcff",
"terminal.ansi.dim_white": "#b0a189ff",
"link_text.hover": "#0b6678ff",
"version_control.added": "#797410ff",
diff --git a/assets/themes/one/one.json b/assets/themes/one/one.json
index 33f6d3c622..23ebbcc67e 100644
--- a/assets/themes/one/one.json
+++ b/assets/themes/one/one.json
@@ -93,7 +93,7 @@
"terminal.ansi.bright_cyan": "#3a565bff",
"terminal.ansi.dim_cyan": "#b9d9dfff",
"terminal.ansi.white": "#dce0e5ff",
- "terminal.ansi.bright_white": "#fafafaff",
+ "terminal.ansi.bright_white": "#dce0e5ff",
"terminal.ansi.dim_white": "#575d65ff",
"link_text.hover": "#74ade8ff",
"version_control.added": "#27a657ff",
@@ -468,7 +468,7 @@
"terminal.bright_foreground": "#242529ff",
"terminal.dim_foreground": "#fafafaff",
"terminal.ansi.black": "#242529ff",
- "terminal.ansi.bright_black": "#747579ff",
+ "terminal.ansi.bright_black": "#242529ff",
"terminal.ansi.dim_black": "#97979aff",
"terminal.ansi.red": "#d36151ff",
"terminal.ansi.bright_red": "#f0b0a4ff",
@@ -489,7 +489,7 @@
"terminal.ansi.bright_cyan": "#a3bedaff",
"terminal.ansi.dim_cyan": "#254058ff",
"terminal.ansi.white": "#fafafaff",
- "terminal.ansi.bright_white": "#ffffffff",
+ "terminal.ansi.bright_white": "#fafafaff",
"terminal.ansi.dim_white": "#aaaaaaff",
"link_text.hover": "#5c78e2ff",
"version_control.added": "#27a657ff",
diff --git a/crates/acp_thread/src/acp_thread.rs b/crates/acp_thread/src/acp_thread.rs
index 4ded647a74..61bc50576a 100644
--- a/crates/acp_thread/src/acp_thread.rs
+++ b/crates/acp_thread/src/acp_thread.rs
@@ -183,15 +183,16 @@ impl ToolCall {
language_registry: Arc,
cx: &mut App,
) -> Self {
- let title = if let Some((first_line, _)) = tool_call.title.split_once("\n") {
- first_line.to_owned() + "…"
- } else {
- tool_call.title
- };
Self {
id: tool_call.id,
- label: cx
- .new(|cx| Markdown::new(title.into(), Some(language_registry.clone()), None, cx)),
+ label: cx.new(|cx| {
+ Markdown::new(
+ tool_call.title.into(),
+ Some(language_registry.clone()),
+ None,
+ cx,
+ )
+ }),
kind: tool_call.kind,
content: tool_call
.content
@@ -232,30 +233,15 @@ impl ToolCall {
if let Some(title) = title {
self.label.update(cx, |label, cx| {
- if let Some((first_line, _)) = title.split_once("\n") {
- label.replace(first_line.to_owned() + "…", cx)
- } else {
- label.replace(title, cx);
- }
+ label.replace(title, cx);
});
}
if let Some(content) = content {
- let new_content_len = content.len();
- let mut content = content.into_iter();
-
- // Reuse existing content if we can
- for (old, new) in self.content.iter_mut().zip(content.by_ref()) {
- old.update_from_acp(new, language_registry.clone(), cx);
- }
- for new in content {
- self.content.push(ToolCallContent::from_acp(
- new,
- language_registry.clone(),
- cx,
- ))
- }
- self.content.truncate(new_content_len);
+ self.content = content
+ .into_iter()
+ .map(|chunk| ToolCallContent::from_acp(chunk, language_registry.clone(), cx))
+ .collect();
}
if let Some(locations) = locations {
@@ -512,7 +498,7 @@ impl ContentBlock {
"`Image`".into()
}
- pub fn to_markdown<'a>(&'a self, cx: &'a App) -> &'a str {
+ fn to_markdown<'a>(&'a self, cx: &'a App) -> &'a str {
match self {
ContentBlock::Empty => "",
ContentBlock::Markdown { markdown } => markdown.read(cx).source(),
@@ -565,28 +551,6 @@ impl ToolCallContent {
}
}
- pub fn update_from_acp(
- &mut self,
- new: acp::ToolCallContent,
- language_registry: Arc,
- cx: &mut App,
- ) {
- let needs_update = match (&self, &new) {
- (Self::Diff(old_diff), acp::ToolCallContent::Diff { diff: new_diff }) => {
- old_diff.read(cx).needs_update(
- new_diff.old_text.as_deref().unwrap_or(""),
- &new_diff.new_text,
- cx,
- )
- }
- _ => true,
- };
-
- if needs_update {
- *self = Self::from_acp(new, language_registry, cx);
- }
- }
-
pub fn to_markdown(&self, cx: &App) -> String {
match self {
Self::ContentBlock(content) => content.to_markdown(cx).to_string(),
@@ -759,8 +723,6 @@ pub struct AcpThread {
connection: Rc,
session_id: acp::SessionId,
token_usage: Option,
- prompt_capabilities: acp::PromptCapabilities,
- _observe_prompt_capabilities: Task>,
}
#[derive(Debug)]
@@ -775,12 +737,11 @@ pub enum AcpThreadEvent {
Stopped,
Error,
LoadError(LoadError),
- PromptCapabilitiesUpdated,
}
impl EventEmitter for AcpThread {}
-#[derive(PartialEq, Eq, Debug)]
+#[derive(PartialEq, Eq)]
pub enum ThreadStatus {
Idle,
WaitingForToolConfirmation,
@@ -827,20 +788,7 @@ impl AcpThread {
project: Entity,
action_log: Entity,
session_id: acp::SessionId,
- mut prompt_capabilities_rx: watch::Receiver,
- cx: &mut Context,
) -> Self {
- let prompt_capabilities = *prompt_capabilities_rx.borrow();
- let task = cx.spawn::<_, anyhow::Result<()>>(async move |this, cx| {
- loop {
- let caps = prompt_capabilities_rx.recv().await?;
- this.update(cx, |this, cx| {
- this.prompt_capabilities = caps;
- cx.emit(AcpThreadEvent::PromptCapabilitiesUpdated);
- })?;
- }
- });
-
Self {
action_log,
shared_buffers: Default::default(),
@@ -852,15 +800,9 @@ impl AcpThread {
connection,
session_id,
token_usage: None,
- prompt_capabilities,
- _observe_prompt_capabilities: task,
}
}
- pub fn prompt_capabilities(&self) -> acp::PromptCapabilities {
- self.prompt_capabilities
- }
-
pub fn connection(&self) -> &Rc {
&self.connection
}
@@ -1045,19 +987,10 @@ impl AcpThread {
cx.emit(AcpThreadEvent::NewEntry);
}
- pub fn can_set_title(&mut self, cx: &mut Context) -> bool {
- self.connection.set_title(&self.session_id, cx).is_some()
- }
-
- pub fn set_title(&mut self, title: SharedString, cx: &mut Context) -> Task> {
- if title != self.title {
- self.title = title.clone();
- cx.emit(AcpThreadEvent::TitleUpdated);
- if let Some(set_title) = self.connection.set_title(&self.session_id, cx) {
- return set_title.run(title, cx);
- }
- }
- Task::ready(Ok(()))
+ pub fn update_title(&mut self, title: SharedString, cx: &mut Context) -> Result<()> {
+ self.title = title;
+ cx.emit(AcpThreadEvent::TitleUpdated);
+ Ok(())
}
pub fn update_token_usage(&mut self, usage: Option, cx: &mut Context) {
@@ -1360,7 +1293,11 @@ impl AcpThread {
};
let git_store = self.project.read(cx).git_store().clone();
- let message_id = if self.connection.truncate(&self.session_id, cx).is_some() {
+ let message_id = if self
+ .connection
+ .session_editor(&self.session_id, cx)
+ .is_some()
+ {
Some(UserMessageId::new())
} else {
None
@@ -1398,10 +1335,6 @@ impl AcpThread {
})
}
- pub fn can_resume(&self, cx: &App) -> bool {
- self.connection.resume(&self.session_id, cx).is_some()
- }
-
pub fn resume(&mut self, cx: &mut Context) -> BoxFuture<'static, Result<()>> {
self.run_turn(cx, async move |this, cx| {
this.update(cx, |this, cx| {
@@ -1510,7 +1443,7 @@ impl AcpThread {
/// Rewinds this thread to before the entry at `index`, removing it and all
/// subsequent entries while reverting any changes made from that point.
pub fn rewind(&mut self, id: UserMessageId, cx: &mut Context) -> Task> {
- let Some(truncate) = self.connection.truncate(&self.session_id, cx) else {
+ let Some(session_editor) = self.connection.session_editor(&self.session_id, cx) else {
return Task::ready(Err(anyhow!("not supported")));
};
let Some(message) = self.user_message(&id) else {
@@ -1530,7 +1463,8 @@ impl AcpThread {
.await?;
}
- cx.update(|cx| truncate.run(id.clone(), cx))?.await?;
+ cx.update(|cx| session_editor.truncate(id.clone(), cx))?
+ .await?;
this.update(cx, |this, cx| {
if let Some((ix, _)) = this.user_message_mut(&id) {
let range = ix..this.entries.len();
@@ -2624,19 +2558,13 @@ mod tests {
.into(),
);
let action_log = cx.new(|_| ActionLog::new(project.clone()));
- let thread = cx.new(|cx| {
+ let thread = cx.new(|_cx| {
AcpThread::new(
"Test",
self.clone(),
project,
action_log,
session_id.clone(),
- watch::Receiver::constant(acp::PromptCapabilities {
- image: true,
- audio: true,
- embedded_context: true,
- }),
- cx,
)
});
self.sessions.lock().insert(session_id, thread.downgrade());
@@ -2670,6 +2598,14 @@ mod tests {
}
}
+ fn prompt_capabilities(&self) -> acp::PromptCapabilities {
+ acp::PromptCapabilities {
+ image: true,
+ audio: true,
+ embedded_context: true,
+ }
+ }
+
fn cancel(&self, session_id: &acp::SessionId, cx: &mut App) {
let sessions = self.sessions.lock();
let thread = sessions.get(session_id).unwrap().clone();
@@ -2683,11 +2619,11 @@ mod tests {
.detach();
}
- fn truncate(
+ fn session_editor(
&self,
session_id: &acp::SessionId,
- _cx: &App,
- ) -> Option> {
+ _cx: &mut App,
+ ) -> Option> {
Some(Rc::new(FakeAgentSessionEditor {
_session_id: session_id.clone(),
}))
@@ -2702,8 +2638,8 @@ mod tests {
_session_id: acp::SessionId,
}
- impl AgentSessionTruncate for FakeAgentSessionEditor {
- fn run(&self, _message_id: UserMessageId, _cx: &mut App) -> Task> {
+ impl AgentSessionEditor for FakeAgentSessionEditor {
+ fn truncate(&self, _message_id: UserMessageId, _cx: &mut App) -> Task> {
Task::ready(Ok(()))
}
}
diff --git a/crates/acp_thread/src/connection.rs b/crates/acp_thread/src/connection.rs
index af229b7545..2bbd364873 100644
--- a/crates/acp_thread/src/connection.rs
+++ b/crates/acp_thread/src/connection.rs
@@ -38,29 +38,23 @@ pub trait AgentConnection {
cx: &mut App,
) -> Task>;
+ fn prompt_capabilities(&self) -> acp::PromptCapabilities;
+
fn resume(
&self,
_session_id: &acp::SessionId,
- _cx: &App,
+ _cx: &mut App,
) -> Option> {
None
}
fn cancel(&self, session_id: &acp::SessionId, cx: &mut App);
- fn truncate(
+ fn session_editor(
&self,
_session_id: &acp::SessionId,
- _cx: &App,
- ) -> Option> {
- None
- }
-
- fn set_title(
- &self,
- _session_id: &acp::SessionId,
- _cx: &App,
- ) -> Option> {
+ _cx: &mut App,
+ ) -> Option> {
None
}
@@ -85,18 +79,14 @@ impl dyn AgentConnection {
}
}
-pub trait AgentSessionTruncate {
- fn run(&self, message_id: UserMessageId, cx: &mut App) -> Task>;
+pub trait AgentSessionEditor {
+ fn truncate(&self, message_id: UserMessageId, cx: &mut App) -> Task>;
}
pub trait AgentSessionResume {
fn run(&self, cx: &mut App) -> Task>;
}
-pub trait AgentSessionSetTitle {
- fn run(&self, title: SharedString, cx: &mut App) -> Task>;
-}
-
pub trait AgentTelemetry {
/// The name of the agent used for telemetry.
fn agent_name(&self) -> String;
@@ -327,19 +317,13 @@ mod test_support {
) -> Task>> {
let session_id = acp::SessionId(self.sessions.lock().len().to_string().into());
let action_log = cx.new(|_| ActionLog::new(project.clone()));
- let thread = cx.new(|cx| {
+ let thread = cx.new(|_cx| {
AcpThread::new(
"Test",
self.clone(),
project,
action_log,
session_id.clone(),
- watch::Receiver::constant(acp::PromptCapabilities {
- image: true,
- audio: true,
- embedded_context: true,
- }),
- cx,
)
});
self.sessions.lock().insert(
@@ -352,6 +336,14 @@ mod test_support {
Task::ready(Ok(thread))
}
+ fn prompt_capabilities(&self) -> acp::PromptCapabilities {
+ acp::PromptCapabilities {
+ image: true,
+ audio: true,
+ embedded_context: true,
+ }
+ }
+
fn authenticate(
&self,
_method_id: acp::AuthMethodId,
@@ -432,11 +424,11 @@ mod test_support {
}
}
- fn truncate(
+ fn session_editor(
&self,
_session_id: &agent_client_protocol::SessionId,
- _cx: &App,
- ) -> Option> {
+ _cx: &mut App,
+ ) -> Option> {
Some(Rc::new(StubAgentSessionEditor))
}
@@ -447,8 +439,8 @@ mod test_support {
struct StubAgentSessionEditor;
- impl AgentSessionTruncate for StubAgentSessionEditor {
- fn run(&self, _: UserMessageId, _: &mut App) -> Task> {
+ impl AgentSessionEditor for StubAgentSessionEditor {
+ fn truncate(&self, _: UserMessageId, _: &mut App) -> Task> {
Task::ready(Ok(()))
}
}
diff --git a/crates/acp_thread/src/diff.rs b/crates/acp_thread/src/diff.rs
index 0fec6809e0..130bc3ab6b 100644
--- a/crates/acp_thread/src/diff.rs
+++ b/crates/acp_thread/src/diff.rs
@@ -28,12 +28,10 @@ impl Diff {
cx: &mut Context,
) -> Self {
let multibuffer = cx.new(|_cx| MultiBuffer::without_headers(Capability::ReadOnly));
- let new_buffer = cx.new(|cx| Buffer::local(new_text, cx));
- let base_text = old_text.clone().unwrap_or(String::new()).into();
+ let buffer = cx.new(|cx| Buffer::local(new_text, cx));
let task = cx.spawn({
let multibuffer = multibuffer.clone();
let path = path.clone();
- let buffer = new_buffer.clone();
async move |_, cx| {
let language = language_registry
.language_for_file_path(&path)
@@ -78,26 +76,32 @@ impl Diff {
Self::Finalized(FinalizedDiff {
multibuffer,
path,
- base_text,
- new_buffer,
_update_diff: task,
})
}
pub fn new(buffer: Entity, cx: &mut Context) -> Self {
- let buffer_text_snapshot = buffer.read(cx).text_snapshot();
- let base_text_snapshot = buffer.read(cx).snapshot();
- let base_text = base_text_snapshot.text();
- debug_assert_eq!(buffer_text_snapshot.text(), base_text);
+ let buffer_snapshot = buffer.read(cx).snapshot();
+ let base_text = buffer_snapshot.text();
+ let language_registry = buffer.read(cx).language_registry();
+ let text_snapshot = buffer.read(cx).text_snapshot();
let buffer_diff = cx.new(|cx| {
- let mut diff = BufferDiff::new_unchanged(&buffer_text_snapshot, base_text_snapshot);
+ let mut diff = BufferDiff::new(&text_snapshot, cx);
+ let _ = diff.set_base_text(
+ buffer_snapshot.clone(),
+ language_registry,
+ text_snapshot,
+ cx,
+ );
let snapshot = diff.snapshot(cx);
+
let secondary_diff = cx.new(|cx| {
- let mut diff = BufferDiff::new(&buffer_text_snapshot, cx);
- diff.set_snapshot(snapshot, &buffer_text_snapshot, cx);
+ let mut diff = BufferDiff::new(&buffer_snapshot, cx);
+ diff.set_snapshot(snapshot, &buffer_snapshot, cx);
diff
});
diff.set_secondary_diff(secondary_diff);
+
diff
});
@@ -115,7 +119,7 @@ impl Diff {
diff.update(cx);
}
}),
- new_buffer: buffer,
+ buffer,
diff: buffer_diff,
revealed_ranges: Vec::new(),
update_diff: Task::ready(Ok(())),
@@ -150,9 +154,9 @@ impl Diff {
.map(|buffer| buffer.read(cx).text())
.join("\n");
let path = match self {
- Diff::Pending(PendingDiff {
- new_buffer: buffer, ..
- }) => buffer.read(cx).file().map(|file| file.path().as_ref()),
+ Diff::Pending(PendingDiff { buffer, .. }) => {
+ buffer.read(cx).file().map(|file| file.path().as_ref())
+ }
Diff::Finalized(FinalizedDiff { path, .. }) => Some(path.as_path()),
};
format!(
@@ -165,33 +169,12 @@ impl Diff {
pub fn has_revealed_range(&self, cx: &App) -> bool {
self.multibuffer().read(cx).excerpt_paths().next().is_some()
}
-
- pub fn needs_update(&self, old_text: &str, new_text: &str, cx: &App) -> bool {
- match self {
- Diff::Pending(PendingDiff {
- base_text,
- new_buffer,
- ..
- }) => {
- base_text.as_str() != old_text
- || !new_buffer.read(cx).as_rope().chunks().equals_str(new_text)
- }
- Diff::Finalized(FinalizedDiff {
- base_text,
- new_buffer,
- ..
- }) => {
- base_text.as_str() != old_text
- || !new_buffer.read(cx).as_rope().chunks().equals_str(new_text)
- }
- }
- }
}
pub struct PendingDiff {
multibuffer: Entity,
base_text: Arc,
- new_buffer: Entity,
+ buffer: Entity,
diff: Entity,
revealed_ranges: Vec>,
_subscription: Subscription,
@@ -200,7 +183,7 @@ pub struct PendingDiff {
impl PendingDiff {
pub fn update(&mut self, cx: &mut Context) {
- let buffer = self.new_buffer.clone();
+ let buffer = self.buffer.clone();
let buffer_diff = self.diff.clone();
let base_text = self.base_text.clone();
self.update_diff = cx.spawn(async move |diff, cx| {
@@ -238,10 +221,10 @@ impl PendingDiff {
fn finalize(&self, cx: &mut Context) -> FinalizedDiff {
let ranges = self.excerpt_ranges(cx);
let base_text = self.base_text.clone();
- let language_registry = self.new_buffer.read(cx).language_registry();
+ let language_registry = self.buffer.read(cx).language_registry();
let path = self
- .new_buffer
+ .buffer
.read(cx)
.file()
.map(|file| file.path().as_ref())
@@ -250,12 +233,12 @@ impl PendingDiff {
// Replace the buffer in the multibuffer with the snapshot
let buffer = cx.new(|cx| {
- let language = self.new_buffer.read(cx).language().cloned();
+ let language = self.buffer.read(cx).language().cloned();
let buffer = TextBuffer::new_normalized(
0,
cx.entity_id().as_non_zero_u64().into(),
- self.new_buffer.read(cx).line_ending(),
- self.new_buffer.read(cx).as_rope().clone(),
+ self.buffer.read(cx).line_ending(),
+ self.buffer.read(cx).as_rope().clone(),
);
let mut buffer = Buffer::build(buffer, None, Capability::ReadWrite);
buffer.set_language(language, cx);
@@ -291,9 +274,7 @@ impl PendingDiff {
FinalizedDiff {
path,
- base_text: self.base_text.clone(),
multibuffer: self.multibuffer.clone(),
- new_buffer: self.new_buffer.clone(),
_update_diff: update_diff,
}
}
@@ -302,8 +283,8 @@ impl PendingDiff {
let ranges = self.excerpt_ranges(cx);
self.multibuffer.update(cx, |multibuffer, cx| {
multibuffer.set_excerpts_for_path(
- PathKey::for_buffer(&self.new_buffer, cx),
- self.new_buffer.clone(),
+ PathKey::for_buffer(&self.buffer, cx),
+ self.buffer.clone(),
ranges,
editor::DEFAULT_MULTIBUFFER_CONTEXT,
cx,
@@ -315,7 +296,7 @@ impl PendingDiff {
}
fn excerpt_ranges(&self, cx: &App) -> Vec> {
- let buffer = self.new_buffer.read(cx);
+ let buffer = self.buffer.read(cx);
let diff = self.diff.read(cx);
let mut ranges = diff
.hunks_intersecting_range(Anchor::MIN..Anchor::MAX, buffer, cx)
@@ -349,8 +330,6 @@ impl PendingDiff {
pub struct FinalizedDiff {
path: PathBuf,
- base_text: Arc,
- new_buffer: Entity,
multibuffer: Entity,
_update_diff: Task>,
}
@@ -404,21 +383,3 @@ async fn build_buffer_diff(
diff
})
}
-
-#[cfg(test)]
-mod tests {
- use gpui::{AppContext as _, TestAppContext};
- use language::Buffer;
-
- use crate::Diff;
-
- #[gpui::test]
- async fn test_pending_diff(cx: &mut TestAppContext) {
- let buffer = cx.new(|cx| Buffer::local("hello!", cx));
- let _diff = cx.new(|cx| Diff::new(buffer.clone(), cx));
- buffer.update(cx, |buffer, cx| {
- buffer.set_text("HELLO!", cx);
- });
- cx.run_until_parked();
- }
-}
diff --git a/crates/acp_thread/src/mention.rs b/crates/acp_thread/src/mention.rs
index 6fa0887e22..a1e713cffa 100644
--- a/crates/acp_thread/src/mention.rs
+++ b/crates/acp_thread/src/mention.rs
@@ -5,7 +5,7 @@ use prompt_store::{PromptId, UserPromptId};
use serde::{Deserialize, Serialize};
use std::{
fmt,
- ops::RangeInclusive,
+ ops::Range,
path::{Path, PathBuf},
str::FromStr,
};
@@ -17,14 +17,13 @@ pub enum MentionUri {
File {
abs_path: PathBuf,
},
- PastedImage,
Directory {
abs_path: PathBuf,
},
Symbol {
- abs_path: PathBuf,
+ path: PathBuf,
name: String,
- line_range: RangeInclusive,
+ line_range: Range,
},
Thread {
id: acp::SessionId,
@@ -39,9 +38,8 @@ pub enum MentionUri {
name: String,
},
Selection {
- #[serde(default, skip_serializing_if = "Option::is_none")]
- abs_path: Option,
- line_range: RangeInclusive,
+ path: PathBuf,
+ line_range: Range,
},
Fetch {
url: Url,
@@ -50,44 +48,36 @@ pub enum MentionUri {
impl MentionUri {
pub fn parse(input: &str) -> Result {
- fn parse_line_range(fragment: &str) -> Result> {
- 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 range = start
- .parse::()
- .context("Parsing line range start")?
- .checked_sub(1)
- .context("Line numbers should be 1-based")?
- ..=end
- .parse::()
- .context("Parsing line range end")?
- .checked_sub(1)
- .context("Line numbers should be 1-based")?;
- Ok(range)
- }
-
let url = url::Url::parse(input)?;
let path = url.path();
match url.scheme() {
"file" => {
let path = url.to_file_path().ok().context("Extracting file path")?;
if let Some(fragment) = url.fragment() {
- let line_range = parse_line_range(fragment)?;
+ 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::()
+ .context("Parsing line range start")?
+ .checked_sub(1)
+ .context("Line numbers should be 1-based")?
+ ..end
+ .parse::()
+ .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,
- abs_path: path,
+ path,
line_range,
})
} else {
- Ok(Self::Selection {
- abs_path: Some(path),
- line_range,
- })
+ Ok(Self::Selection { path, line_range })
}
} else if input.ends_with("/") {
Ok(Self::Directory { abs_path: path })
@@ -115,17 +105,6 @@ impl MentionUri {
id: rule_id.into(),
name,
})
- } else if path.starts_with("/agent/pasted-image") {
- Ok(Self::PastedImage)
- } else if path.starts_with("/agent/untitled-buffer") {
- let fragment = url
- .fragment()
- .context("Missing fragment for untitled buffer selection")?;
- let line_range = parse_line_range(fragment)?;
- Ok(Self::Selection {
- abs_path: None,
- line_range,
- })
} else {
bail!("invalid zed url: {:?}", input);
}
@@ -142,16 +121,13 @@ impl MentionUri {
.unwrap_or_default()
.to_string_lossy()
.into_owned(),
- MentionUri::PastedImage => "Image".to_string(),
MentionUri::Symbol { name, .. } => name.clone(),
MentionUri::Thread { name, .. } => name.clone(),
MentionUri::TextThread { name, .. } => name.clone(),
MentionUri::Rule { name, .. } => name.clone(),
MentionUri::Selection {
- abs_path: path,
- line_range,
- ..
- } => selection_name(path.as_deref(), line_range),
+ path, line_range, ..
+ } => selection_name(path, line_range),
MentionUri::Fetch { url } => url.to_string(),
}
}
@@ -161,7 +137,6 @@ impl MentionUri {
MentionUri::File { abs_path } => {
FileIcons::get_icon(abs_path, cx).unwrap_or_else(|| IconName::File.path().into())
}
- MentionUri::PastedImage => IconName::Image.path().into(),
MentionUri::Directory { .. } => FileIcons::get_folder_icon(false, cx)
.unwrap_or_else(|| IconName::Folder.path().into()),
MentionUri::Symbol { .. } => IconName::Code.path().into(),
@@ -182,40 +157,29 @@ impl MentionUri {
MentionUri::File { abs_path } => {
Url::from_file_path(abs_path).expect("mention path should be absolute")
}
- MentionUri::PastedImage => Url::parse("zed:///agent/pasted-image").unwrap(),
MentionUri::Directory { abs_path } => {
Url::from_directory_path(abs_path).expect("mention path should be absolute")
}
MentionUri::Symbol {
- abs_path,
+ path,
name,
line_range,
} => {
- let mut url =
- Url::from_file_path(abs_path).expect("mention path should be absolute");
+ let mut url = Url::from_file_path(path).expect("mention path should be absolute");
url.query_pairs_mut().append_pair("symbol", name);
url.set_fragment(Some(&format!(
"L{}:{}",
- line_range.start() + 1,
- line_range.end() + 1
+ line_range.start + 1,
+ line_range.end + 1
)));
url
}
- MentionUri::Selection {
- abs_path: path,
- line_range,
- } => {
- let mut url = if let Some(path) = path {
- Url::from_file_path(path).expect("mention path should be absolute")
- } else {
- let mut url = Url::parse("zed:///").unwrap();
- url.set_path("/agent/untitled-buffer");
- url
- };
+ MentionUri::Selection { path, line_range } => {
+ let mut url = Url::from_file_path(path).expect("mention path should be absolute");
url.set_fragment(Some(&format!(
"L{}:{}",
- line_range.start() + 1,
- line_range.end() + 1
+ line_range.start + 1,
+ line_range.end + 1
)));
url
}
@@ -227,10 +191,7 @@ impl MentionUri {
}
MentionUri::TextThread { path, name } => {
let mut url = Url::parse("zed:///").unwrap();
- url.set_path(&format!(
- "/agent/text-thread/{}",
- path.to_string_lossy().trim_start_matches('/')
- ));
+ url.set_path(&format!("/agent/text-thread/{}", path.to_string_lossy()));
url.query_pairs_mut().append_pair("name", name);
url
}
@@ -276,14 +237,12 @@ fn single_query_param(url: &Url, name: &'static str) -> Result> {
}
}
-pub fn selection_name(path: Option<&Path>, line_range: &RangeInclusive) -> String {
+pub fn selection_name(path: &Path, line_range: &Range) -> String {
format!(
"{} ({}:{})",
- path.and_then(|path| path.file_name())
- .unwrap_or("Untitled".as_ref())
- .display(),
- *line_range.start() + 1,
- *line_range.end() + 1
+ path.file_name().unwrap_or_default().display(),
+ line_range.start + 1,
+ line_range.end + 1
)
}
@@ -343,14 +302,14 @@ mod tests {
let parsed = MentionUri::parse(symbol_uri).unwrap();
match &parsed {
MentionUri::Symbol {
- abs_path: path,
+ path,
name,
line_range,
} => {
assert_eq!(path.to_str().unwrap(), path!("/path/to/file.rs"));
assert_eq!(name, "MySymbol");
- assert_eq!(line_range.start(), &9);
- assert_eq!(line_range.end(), &19);
+ assert_eq!(line_range.start, 9);
+ assert_eq!(line_range.end, 19);
}
_ => panic!("Expected Symbol variant"),
}
@@ -362,39 +321,16 @@ mod tests {
let selection_uri = uri!("file:///path/to/file.rs#L5:15");
let parsed = MentionUri::parse(selection_uri).unwrap();
match &parsed {
- MentionUri::Selection {
- abs_path: path,
- line_range,
- } => {
- assert_eq!(
- path.as_ref().unwrap().to_str().unwrap(),
- path!("/path/to/file.rs")
- );
- assert_eq!(line_range.start(), &4);
- assert_eq!(line_range.end(), &14);
+ MentionUri::Selection { path, line_range } => {
+ assert_eq!(path.to_str().unwrap(), path!("/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_untitled_selection_uri() {
- let selection_uri = uri!("zed:///agent/untitled-buffer#L1:10");
- let parsed = MentionUri::parse(selection_uri).unwrap();
- match &parsed {
- MentionUri::Selection {
- abs_path: None,
- line_range,
- } => {
- assert_eq!(line_range.start(), &0);
- assert_eq!(line_range.end(), &9);
- }
- _ => panic!("Expected Selection variant without path"),
- }
- 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";
diff --git a/crates/acp_tools/Cargo.toml b/crates/acp_tools/Cargo.toml
deleted file mode 100644
index 7a6d8c21a0..0000000000
--- a/crates/acp_tools/Cargo.toml
+++ /dev/null
@@ -1,30 +0,0 @@
-[package]
-name = "acp_tools"
-version = "0.1.0"
-edition.workspace = true
-publish.workspace = true
-license = "GPL-3.0-or-later"
-
-
-[lints]
-workspace = true
-
-[lib]
-path = "src/acp_tools.rs"
-doctest = false
-
-[dependencies]
-agent-client-protocol.workspace = true
-collections.workspace = true
-gpui.workspace = true
-language.workspace= true
-markdown.workspace = true
-project.workspace = true
-serde.workspace = true
-serde_json.workspace = true
-settings.workspace = true
-theme.workspace = true
-ui.workspace = true
-util.workspace = true
-workspace-hack.workspace = true
-workspace.workspace = true
diff --git a/crates/acp_tools/LICENSE-GPL b/crates/acp_tools/LICENSE-GPL
deleted file mode 120000
index 89e542f750..0000000000
--- a/crates/acp_tools/LICENSE-GPL
+++ /dev/null
@@ -1 +0,0 @@
-../../LICENSE-GPL
\ No newline at end of file
diff --git a/crates/acp_tools/src/acp_tools.rs b/crates/acp_tools/src/acp_tools.rs
deleted file mode 100644
index e20a040e9d..0000000000
--- a/crates/acp_tools/src/acp_tools.rs
+++ /dev/null
@@ -1,494 +0,0 @@
-use std::{
- cell::RefCell,
- collections::HashSet,
- fmt::Display,
- rc::{Rc, Weak},
- sync::Arc,
-};
-
-use agent_client_protocol as acp;
-use collections::HashMap;
-use gpui::{
- App, Empty, Entity, EventEmitter, FocusHandle, Focusable, Global, ListAlignment, ListState,
- StyleRefinement, Subscription, Task, TextStyleRefinement, Window, actions, list, prelude::*,
-};
-use language::LanguageRegistry;
-use markdown::{CodeBlockRenderer, Markdown, MarkdownElement, MarkdownStyle};
-use project::Project;
-use settings::Settings;
-use theme::ThemeSettings;
-use ui::prelude::*;
-use util::ResultExt as _;
-use workspace::{Item, Workspace};
-
-actions!(dev, [OpenAcpLogs]);
-
-pub fn init(cx: &mut App) {
- cx.observe_new(
- |workspace: &mut Workspace, _window, _cx: &mut Context| {
- workspace.register_action(|workspace, _: &OpenAcpLogs, window, cx| {
- let acp_tools =
- Box::new(cx.new(|cx| AcpTools::new(workspace.project().clone(), cx)));
- workspace.add_item_to_active_pane(acp_tools, None, true, window, cx);
- });
- },
- )
- .detach();
-}
-
-struct GlobalAcpConnectionRegistry(Entity);
-
-impl Global for GlobalAcpConnectionRegistry {}
-
-#[derive(Default)]
-pub struct AcpConnectionRegistry {
- active_connection: RefCell>,
-}
-
-struct ActiveConnection {
- server_name: SharedString,
- connection: Weak,
-}
-
-impl AcpConnectionRegistry {
- pub fn default_global(cx: &mut App) -> Entity {
- if cx.has_global::() {
- cx.global::().0.clone()
- } else {
- let registry = cx.new(|_cx| AcpConnectionRegistry::default());
- cx.set_global(GlobalAcpConnectionRegistry(registry.clone()));
- registry
- }
- }
-
- pub fn set_active_connection(
- &self,
- server_name: impl Into,
- connection: &Rc,
- cx: &mut Context,
- ) {
- self.active_connection.replace(Some(ActiveConnection {
- server_name: server_name.into(),
- connection: Rc::downgrade(connection),
- }));
- cx.notify();
- }
-}
-
-struct AcpTools {
- project: Entity,
- focus_handle: FocusHandle,
- expanded: HashSet,
- watched_connection: Option,
- connection_registry: Entity,
- _subscription: Subscription,
-}
-
-struct WatchedConnection {
- server_name: SharedString,
- messages: Vec,
- list_state: ListState,
- connection: Weak,
- incoming_request_methods: HashMap>,
- outgoing_request_methods: HashMap>,
- _task: Task<()>,
-}
-
-impl AcpTools {
- fn new(project: Entity, cx: &mut Context) -> Self {
- let connection_registry = AcpConnectionRegistry::default_global(cx);
-
- let subscription = cx.observe(&connection_registry, |this, _, cx| {
- this.update_connection(cx);
- cx.notify();
- });
-
- let mut this = Self {
- project,
- focus_handle: cx.focus_handle(),
- expanded: HashSet::default(),
- watched_connection: None,
- connection_registry,
- _subscription: subscription,
- };
- this.update_connection(cx);
- this
- }
-
- fn update_connection(&mut self, cx: &mut Context) {
- let active_connection = self.connection_registry.read(cx).active_connection.borrow();
- let Some(active_connection) = active_connection.as_ref() else {
- return;
- };
-
- if let Some(watched_connection) = self.watched_connection.as_ref() {
- if Weak::ptr_eq(
- &watched_connection.connection,
- &active_connection.connection,
- ) {
- return;
- }
- }
-
- if let Some(connection) = active_connection.connection.upgrade() {
- let mut receiver = connection.subscribe();
- let task = cx.spawn(async move |this, cx| {
- while let Ok(message) = receiver.recv().await {
- this.update(cx, |this, cx| {
- this.push_stream_message(message, cx);
- })
- .ok();
- }
- });
-
- self.watched_connection = Some(WatchedConnection {
- server_name: active_connection.server_name.clone(),
- messages: vec![],
- list_state: ListState::new(0, ListAlignment::Bottom, px(2048.)),
- connection: active_connection.connection.clone(),
- incoming_request_methods: HashMap::default(),
- outgoing_request_methods: HashMap::default(),
- _task: task,
- });
- }
- }
-
- fn push_stream_message(&mut self, stream_message: acp::StreamMessage, cx: &mut Context) {
- let Some(connection) = self.watched_connection.as_mut() else {
- return;
- };
- let language_registry = self.project.read(cx).languages().clone();
- let index = connection.messages.len();
-
- let (request_id, method, message_type, params) = match stream_message.message {
- acp::StreamMessageContent::Request { id, method, params } => {
- let method_map = match stream_message.direction {
- acp::StreamMessageDirection::Incoming => {
- &mut connection.incoming_request_methods
- }
- acp::StreamMessageDirection::Outgoing => {
- &mut connection.outgoing_request_methods
- }
- };
-
- method_map.insert(id, method.clone());
- (Some(id), method.into(), MessageType::Request, Ok(params))
- }
- acp::StreamMessageContent::Response { id, result } => {
- let method_map = match stream_message.direction {
- acp::StreamMessageDirection::Incoming => {
- &mut connection.outgoing_request_methods
- }
- acp::StreamMessageDirection::Outgoing => {
- &mut connection.incoming_request_methods
- }
- };
-
- if let Some(method) = method_map.remove(&id) {
- (Some(id), method.into(), MessageType::Response, result)
- } else {
- (
- Some(id),
- "[unrecognized response]".into(),
- MessageType::Response,
- result,
- )
- }
- }
- acp::StreamMessageContent::Notification { method, params } => {
- (None, method.into(), MessageType::Notification, Ok(params))
- }
- };
-
- let message = WatchedConnectionMessage {
- name: method,
- message_type,
- request_id,
- direction: stream_message.direction,
- collapsed_params_md: match params.as_ref() {
- Ok(params) => params
- .as_ref()
- .map(|params| collapsed_params_md(params, &language_registry, cx)),
- Err(err) => {
- if let Ok(err) = &serde_json::to_value(err) {
- Some(collapsed_params_md(&err, &language_registry, cx))
- } else {
- None
- }
- }
- },
-
- expanded_params_md: None,
- params,
- };
-
- connection.messages.push(message);
- connection.list_state.splice(index..index, 1);
- cx.notify();
- }
-
- fn render_message(
- &mut self,
- index: usize,
- window: &mut Window,
- cx: &mut Context,
- ) -> AnyElement {
- let Some(connection) = self.watched_connection.as_ref() else {
- return Empty.into_any();
- };
-
- let Some(message) = connection.messages.get(index) else {
- return Empty.into_any();
- };
-
- let base_size = TextSize::Editor.rems(cx);
-
- let theme_settings = ThemeSettings::get_global(cx);
- let text_style = window.text_style();
-
- let colors = cx.theme().colors();
- let expanded = self.expanded.contains(&index);
-
- v_flex()
- .w_full()
- .px_4()
- .py_3()
- .border_color(colors.border)
- .border_b_1()
- .gap_2()
- .items_start()
- .font_buffer(cx)
- .text_size(base_size)
- .id(index)
- .group("message")
- .hover(|this| this.bg(colors.element_background.opacity(0.5)))
- .on_click(cx.listener(move |this, _, _, cx| {
- if this.expanded.contains(&index) {
- this.expanded.remove(&index);
- } else {
- this.expanded.insert(index);
- let Some(connection) = &mut this.watched_connection else {
- return;
- };
- let Some(message) = connection.messages.get_mut(index) else {
- return;
- };
- message.expanded(this.project.read(cx).languages().clone(), cx);
- connection.list_state.scroll_to_reveal_item(index);
- }
- cx.notify()
- }))
- .child(
- h_flex()
- .w_full()
- .gap_2()
- .items_center()
- .flex_shrink_0()
- .child(match message.direction {
- acp::StreamMessageDirection::Incoming => {
- ui::Icon::new(ui::IconName::ArrowDown).color(Color::Error)
- }
- acp::StreamMessageDirection::Outgoing => {
- ui::Icon::new(ui::IconName::ArrowUp).color(Color::Success)
- }
- })
- .child(
- Label::new(message.name.clone())
- .buffer_font(cx)
- .color(Color::Muted),
- )
- .child(div().flex_1())
- .child(
- div()
- .child(ui::Chip::new(message.message_type.to_string()))
- .visible_on_hover("message"),
- )
- .children(
- message
- .request_id
- .map(|req_id| div().child(ui::Chip::new(req_id.to_string()))),
- ),
- )
- // I'm aware using markdown is a hack. Trying to get something working for the demo.
- // Will clean up soon!
- .when_some(
- if expanded {
- message.expanded_params_md.clone()
- } else {
- message.collapsed_params_md.clone()
- },
- |this, params| {
- this.child(
- div().pl_6().w_full().child(
- MarkdownElement::new(
- params,
- MarkdownStyle {
- base_text_style: text_style,
- selection_background_color: colors.element_selection_background,
- syntax: cx.theme().syntax().clone(),
- code_block_overflow_x_scroll: true,
- code_block: StyleRefinement {
- text: Some(TextStyleRefinement {
- font_family: Some(
- theme_settings.buffer_font.family.clone(),
- ),
- font_size: Some((base_size * 0.8).into()),
- ..Default::default()
- }),
- ..Default::default()
- },
- ..Default::default()
- },
- )
- .code_block_renderer(
- CodeBlockRenderer::Default {
- copy_button: false,
- copy_button_on_hover: expanded,
- border: false,
- },
- ),
- ),
- )
- },
- )
- .into_any()
- }
-}
-
-struct WatchedConnectionMessage {
- name: SharedString,
- request_id: Option,
- direction: acp::StreamMessageDirection,
- message_type: MessageType,
- params: Result, acp::Error>,
- collapsed_params_md: Option>,
- expanded_params_md: Option>,
-}
-
-impl WatchedConnectionMessage {
- fn expanded(&mut self, language_registry: Arc, cx: &mut App) {
- let params_md = match &self.params {
- Ok(Some(params)) => Some(expanded_params_md(params, &language_registry, cx)),
- Err(err) => {
- if let Some(err) = &serde_json::to_value(err).log_err() {
- Some(expanded_params_md(&err, &language_registry, cx))
- } else {
- None
- }
- }
- _ => None,
- };
- self.expanded_params_md = params_md;
- }
-}
-
-fn collapsed_params_md(
- params: &serde_json::Value,
- language_registry: &Arc,
- cx: &mut App,
-) -> Entity {
- let params_json = serde_json::to_string(params).unwrap_or_default();
- let mut spaced_out_json = String::with_capacity(params_json.len() + params_json.len() / 4);
-
- for ch in params_json.chars() {
- match ch {
- '{' => spaced_out_json.push_str("{ "),
- '}' => spaced_out_json.push_str(" }"),
- ':' => spaced_out_json.push_str(": "),
- ',' => spaced_out_json.push_str(", "),
- c => spaced_out_json.push(c),
- }
- }
-
- let params_md = format!("```json\n{}\n```", spaced_out_json);
- cx.new(|cx| Markdown::new(params_md.into(), Some(language_registry.clone()), None, cx))
-}
-
-fn expanded_params_md(
- params: &serde_json::Value,
- language_registry: &Arc,
- cx: &mut App,
-) -> Entity {
- let params_json = serde_json::to_string_pretty(params).unwrap_or_default();
- let params_md = format!("```json\n{}\n```", params_json);
- cx.new(|cx| Markdown::new(params_md.into(), Some(language_registry.clone()), None, cx))
-}
-
-enum MessageType {
- Request,
- Response,
- Notification,
-}
-
-impl Display for MessageType {
- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
- match self {
- MessageType::Request => write!(f, "Request"),
- MessageType::Response => write!(f, "Response"),
- MessageType::Notification => write!(f, "Notification"),
- }
- }
-}
-
-enum AcpToolsEvent {}
-
-impl EventEmitter for AcpTools {}
-
-impl Item for AcpTools {
- type Event = AcpToolsEvent;
-
- fn tab_content_text(&self, _detail: usize, _cx: &App) -> ui::SharedString {
- format!(
- "ACP: {}",
- self.watched_connection
- .as_ref()
- .map_or("Disconnected", |connection| &connection.server_name)
- )
- .into()
- }
-
- fn tab_icon(&self, _window: &Window, _cx: &App) -> Option {
- Some(ui::Icon::new(IconName::Thread))
- }
-}
-
-impl Focusable for AcpTools {
- fn focus_handle(&self, _cx: &App) -> FocusHandle {
- self.focus_handle.clone()
- }
-}
-
-impl Render for AcpTools {
- fn render(&mut self, _window: &mut Window, cx: &mut Context) -> impl IntoElement {
- v_flex()
- .track_focus(&self.focus_handle)
- .size_full()
- .bg(cx.theme().colors().editor_background)
- .child(match self.watched_connection.as_ref() {
- Some(connection) => {
- if connection.messages.is_empty() {
- h_flex()
- .size_full()
- .justify_center()
- .items_center()
- .child("No messages recorded yet")
- .into_any()
- } else {
- list(
- connection.list_state.clone(),
- cx.processor(Self::render_message),
- )
- .with_sizing_behavior(gpui::ListSizingBehavior::Auto)
- .flex_grow()
- .into_any()
- }
- }
- None => h_flex()
- .size_full()
- .justify_center()
- .items_center()
- .child("No active connection")
- .into_any(),
- })
- }
-}
diff --git a/crates/agent/src/thread_store.rs b/crates/agent/src/thread_store.rs
index cba2457566..45e551dbdf 100644
--- a/crates/agent/src/thread_store.rs
+++ b/crates/agent/src/thread_store.rs
@@ -893,19 +893,8 @@ impl ThreadsDatabase {
let needs_migration_from_heed = mdb_path.exists();
- let connection = if *ZED_STATELESS {
+ let connection = if *ZED_STATELESS || cfg!(any(feature = "test-support", test)) {
Connection::open_memory(Some("THREAD_FALLBACK_DB"))
- } else if cfg!(any(feature = "test-support", test)) {
- // rust stores the name of the test on the current thread.
- // We use this to automatically create a database that will
- // be shared within the test (for the test_retrieve_old_thread)
- // but not with concurrent tests.
- let thread = std::thread::current();
- let test_name = thread.name();
- Connection::open_memory(Some(&format!(
- "THREAD_FALLBACK_{}",
- test_name.unwrap_or_default()
- )))
} else {
Connection::open_file(&sqlite_path.to_string_lossy())
};
diff --git a/crates/agent2/src/agent.rs b/crates/agent2/src/agent.rs
index 6fa36d33d5..d5bc0fea63 100644
--- a/crates/agent2/src/agent.rs
+++ b/crates/agent2/src/agent.rs
@@ -2,7 +2,7 @@ use crate::{
ContextServerRegistry, Thread, ThreadEvent, ThreadsDatabase, ToolCallAuthorization,
UserMessageContent, templates::Templates,
};
-use crate::{HistoryStore, TitleUpdated, TokenUsageUpdated};
+use crate::{HistoryStore, TokenUsageUpdated};
use acp_thread::{AcpThread, AgentModelSelector};
use action_log::ActionLog;
use agent_client_protocol as acp;
@@ -180,7 +180,7 @@ impl NativeAgent {
fs: Arc,
cx: &mut AsyncApp,
) -> Result> {
- log::debug!("Creating new NativeAgent");
+ log::info!("Creating new NativeAgent");
let project_context = cx
.update(|cx| Self::build_project_context(&project, prompt_store.as_ref(), cx))?
@@ -240,23 +240,19 @@ impl NativeAgent {
let title = thread.title();
let project = thread.project.clone();
let action_log = thread.action_log.clone();
- let prompt_capabilities_rx = thread.prompt_capabilities_rx.clone();
- let acp_thread = cx.new(|cx| {
+ let acp_thread = cx.new(|_cx| {
acp_thread::AcpThread::new(
title,
connection,
project.clone(),
action_log.clone(),
session_id.clone(),
- prompt_capabilities_rx,
- cx,
)
});
let subscriptions = vec![
cx.observe_release(&acp_thread, |this, acp_thread, _cx| {
this.sessions.remove(acp_thread.session_id());
}),
- cx.subscribe(&thread_handle, Self::handle_thread_title_updated),
cx.subscribe(&thread_handle, Self::handle_thread_token_usage_updated),
cx.observe(&thread_handle, move |this, thread, cx| {
this.save_thread(thread, cx)
@@ -445,26 +441,6 @@ impl NativeAgent {
})
}
- fn handle_thread_title_updated(
- &mut self,
- thread: Entity,
- _: &TitleUpdated,
- cx: &mut Context,
- ) {
- let session_id = thread.read(cx).id();
- let Some(session) = self.sessions.get(session_id) else {
- return;
- };
- let thread = thread.downgrade();
- let acp_thread = session.acp_thread.clone();
- cx.spawn(async move |_, cx| {
- let title = thread.read_with(cx, |thread, _| thread.title())?;
- let task = acp_thread.update(cx, |acp_thread, cx| acp_thread.set_title(title, cx))?;
- task.await
- })
- .detach_and_log_err(cx);
- }
-
fn handle_thread_token_usage_updated(
&mut self,
thread: Entity,
@@ -741,6 +717,10 @@ impl NativeAgentConnection {
thread.update_tool_call(update, cx)
})??;
}
+ ThreadEvent::TitleUpdate(title) => {
+ acp_thread
+ .update(cx, |thread, cx| thread.update_title(title, cx))??;
+ }
ThreadEvent::Retry(status) => {
acp_thread.update(cx, |thread, cx| {
thread.update_retry_status(status, cx)
@@ -759,7 +739,7 @@ impl NativeAgentConnection {
}
}
- log::debug!("Response stream completed");
+ log::info!("Response stream completed");
anyhow::Ok(acp::PromptResponse {
stop_reason: acp::StopReason::EndTurn,
})
@@ -784,7 +764,7 @@ impl AgentModelSelector for NativeAgentConnection {
model_id: acp_thread::AgentModelId,
cx: &mut App,
) -> Task> {
- log::debug!("Setting model for session {}: {}", session_id, model_id);
+ log::info!("Setting model for session {}: {}", session_id, model_id);
let Some(thread) = self
.0
.read(cx)
@@ -855,11 +835,12 @@ impl acp_thread::AgentConnection for NativeAgentConnection {
cx: &mut App,
) -> Task>> {
let agent = self.0.clone();
- log::debug!("Creating new thread for project at: {:?}", cwd);
+ log::info!("Creating new thread for project at: {:?}", cwd);
cx.spawn(async move |cx| {
log::debug!("Starting thread creation in async context");
+ let action_log = cx.new(|_cx| ActionLog::new(project.clone()))?;
// Create Thread
let thread = agent.update(
cx,
@@ -875,16 +856,20 @@ impl acp_thread::AgentConnection for NativeAgentConnection {
.models
.model_from_id(&LanguageModels::model_id(&default_model.model))
});
- Ok(cx.new(|cx| {
+
+ let thread = cx.new(|cx| {
Thread::new(
project.clone(),
agent.project_context.clone(),
agent.context_server_registry.clone(),
+ action_log.clone(),
agent.templates.clone(),
default_model,
cx,
)
- }))
+ });
+
+ Ok(thread)
},
)??;
agent.update(cx, |agent, cx| agent.register_session(thread, cx))
@@ -920,7 +905,7 @@ impl acp_thread::AgentConnection for NativeAgentConnection {
.into_iter()
.map(Into::into)
.collect::>();
- log::debug!("Converted prompt to message: {} chars", content.len());
+ log::info!("Converted prompt to message: {} chars", content.len());
log::debug!("Message id: {:?}", id);
log::debug!("Message content: {:?}", content);
@@ -928,10 +913,18 @@ impl acp_thread::AgentConnection for NativeAgentConnection {
})
}
+ fn prompt_capabilities(&self) -> acp::PromptCapabilities {
+ acp::PromptCapabilities {
+ image: true,
+ audio: false,
+ embedded_context: true,
+ }
+ }
+
fn resume(
&self,
session_id: &acp::SessionId,
- _cx: &App,
+ _cx: &mut App,
) -> Option> {
Some(Rc::new(NativeAgentSessionResume {
connection: self.clone(),
@@ -948,12 +941,12 @@ impl acp_thread::AgentConnection for NativeAgentConnection {
});
}
- fn truncate(
+ fn session_editor(
&self,
session_id: &agent_client_protocol::SessionId,
- cx: &App,
- ) -> Option> {
- self.0.read_with(cx, |agent, _cx| {
+ cx: &mut App,
+ ) -> Option> {
+ self.0.update(cx, |agent, _cx| {
agent.sessions.get(session_id).map(|session| {
Rc::new(NativeAgentSessionEditor {
thread: session.thread.clone(),
@@ -963,17 +956,6 @@ impl acp_thread::AgentConnection for NativeAgentConnection {
})
}
- fn set_title(
- &self,
- session_id: &acp::SessionId,
- _cx: &App,
- ) -> Option> {
- Some(Rc::new(NativeAgentSessionSetTitle {
- connection: self.clone(),
- session_id: session_id.clone(),
- }) as _)
- }
-
fn telemetry(&self) -> Option> {
Some(Rc::new(self.clone()) as Rc)
}
@@ -1009,8 +991,8 @@ struct NativeAgentSessionEditor {
acp_thread: WeakEntity,
}
-impl acp_thread::AgentSessionTruncate for NativeAgentSessionEditor {
- fn run(&self, message_id: acp_thread::UserMessageId, cx: &mut App) -> Task> {
+impl acp_thread::AgentSessionEditor for NativeAgentSessionEditor {
+ fn truncate(&self, message_id: acp_thread::UserMessageId, cx: &mut App) -> Task> {
match self.thread.update(cx, |thread, cx| {
thread.truncate(message_id.clone(), cx)?;
Ok(thread.latest_token_usage())
@@ -1042,22 +1024,6 @@ impl acp_thread::AgentSessionResume for NativeAgentSessionResume {
}
}
-struct NativeAgentSessionSetTitle {
- connection: NativeAgentConnection,
- session_id: acp::SessionId,
-}
-
-impl acp_thread::AgentSessionSetTitle for NativeAgentSessionSetTitle {
- fn run(&self, title: SharedString, cx: &mut App) -> Task> {
- let Some(session) = self.connection.0.read(cx).sessions.get(&self.session_id) else {
- return Task::ready(Err(anyhow!("session not found")));
- };
- let thread = session.thread.clone();
- thread.update(cx, |thread, cx| thread.set_title(title, cx));
- Task::ready(Ok(()))
- }
-}
-
#[cfg(test)]
mod tests {
use crate::HistoryEntryId;
@@ -1357,8 +1323,6 @@ mod tests {
)
});
- cx.run_until_parked();
-
// Drop the ACP thread, which should cause the session to be dropped as well.
cx.update(|_| {
drop(thread);
@@ -1401,9 +1365,10 @@ mod tests {
history: &Entity,
cx: &mut TestAppContext,
) -> Vec<(HistoryEntryId, String)> {
- history.read_with(cx, |history, _| {
+ history.read_with(cx, |history, cx| {
history
- .entries()
+ .entries(cx)
+ .iter()
.map(|e| (e.id(), e.title().to_string()))
.collect::>()
})
diff --git a/crates/agent2/src/db.rs b/crates/agent2/src/db.rs
index e7d31c0c7a..1b88955a24 100644
--- a/crates/agent2/src/db.rs
+++ b/crates/agent2/src/db.rs
@@ -266,19 +266,8 @@ impl ThreadsDatabase {
}
pub fn new(executor: BackgroundExecutor) -> Result {
- let connection = if *ZED_STATELESS {
+ let connection = if *ZED_STATELESS || cfg!(any(feature = "test-support", test)) {
Connection::open_memory(Some("THREAD_FALLBACK_DB"))
- } else if cfg!(any(feature = "test-support", test)) {
- // rust stores the name of the test on the current thread.
- // We use this to automatically create a database that will
- // be shared within the test (for the test_retrieve_old_thread)
- // but not with concurrent tests.
- let thread = std::thread::current();
- let test_name = thread.name();
- Connection::open_memory(Some(&format!(
- "THREAD_FALLBACK_{}",
- test_name.unwrap_or_default()
- )))
} else {
let threads_dir = paths::data_dir().join("threads");
std::fs::create_dir_all(&threads_dir)?;
diff --git a/crates/agent2/src/history_store.rs b/crates/agent2/src/history_store.rs
index c656456e01..78d83cc1d0 100644
--- a/crates/agent2/src/history_store.rs
+++ b/crates/agent2/src/history_store.rs
@@ -86,7 +86,6 @@ enum SerializedRecentOpen {
pub struct HistoryStore {
threads: Vec,
- entries: Vec,
context_store: Entity,
recently_opened_entries: VecDeque,
_subscriptions: Vec,
@@ -98,7 +97,7 @@ impl HistoryStore {
context_store: Entity,
cx: &mut Context,
) -> Self {
- let subscriptions = vec![cx.observe(&context_store, |this, _, cx| this.update_entries(cx))];
+ let subscriptions = vec![cx.observe(&context_store, |_, _, cx| cx.notify())];
cx.spawn(async move |this, cx| {
let entries = Self::load_recently_opened_entries(cx).await;
@@ -117,7 +116,6 @@ impl HistoryStore {
context_store,
recently_opened_entries: VecDeque::default(),
threads: Vec::default(),
- entries: Vec::default(),
_subscriptions: subscriptions,
_save_recently_opened_entries_task: Task::ready(()),
}
@@ -183,18 +181,20 @@ impl HistoryStore {
}
}
this.threads = threads;
- this.update_entries(cx);
+ cx.notify();
})
})
.detach_and_log_err(cx);
}
- fn update_entries(&mut self, cx: &mut Context) {
+ pub fn entries(&self, cx: &App) -> Vec {
+ let mut history_entries = Vec::new();
+
#[cfg(debug_assertions)]
if std::env::var("ZED_SIMULATE_NO_THREAD_HISTORY").is_ok() {
- return;
+ return history_entries;
}
- let mut history_entries = Vec::new();
+
history_entries.extend(self.threads.iter().cloned().map(HistoryEntry::AcpThread));
history_entries.extend(
self.context_store
@@ -205,12 +205,17 @@ impl HistoryStore {
);
history_entries.sort_unstable_by_key(|entry| std::cmp::Reverse(entry.updated_at()));
- self.entries = history_entries;
- cx.notify()
+ history_entries
}
- pub fn is_empty(&self, _cx: &App) -> bool {
- self.entries.is_empty()
+ pub fn is_empty(&self, cx: &App) -> bool {
+ self.threads.is_empty()
+ && self
+ .context_store
+ .read(cx)
+ .unordered_contexts()
+ .next()
+ .is_none()
}
pub fn recently_opened_entries(&self, cx: &App) -> Vec {
@@ -351,7 +356,7 @@ impl HistoryStore {
self.save_recently_opened_entries(cx);
}
- pub fn entries(&self) -> impl Iterator- {
- self.entries.iter().cloned()
+ pub fn recent_entries(&self, limit: usize, cx: &mut Context) -> Vec {
+ self.entries(cx).into_iter().take(limit).collect()
}
}
diff --git a/crates/agent2/src/native_agent_server.rs b/crates/agent2/src/native_agent_server.rs
index 9ff98ccd18..ac5aa95c04 100644
--- a/crates/agent2/src/native_agent_server.rs
+++ b/crates/agent2/src/native_agent_server.rs
@@ -3,7 +3,7 @@ use std::{any::Any, path::Path, rc::Rc, sync::Arc};
use agent_servers::AgentServer;
use anyhow::Result;
use fs::Fs;
-use gpui::{App, Entity, SharedString, Task};
+use gpui::{App, Entity, Task};
use project::Project;
use prompt_store::PromptStore;
@@ -22,20 +22,16 @@ impl NativeAgentServer {
}
impl AgentServer for NativeAgentServer {
- fn telemetry_id(&self) -> &'static str {
- "zed"
+ fn name(&self) -> &'static str {
+ "Native Agent"
}
- fn name(&self) -> SharedString {
- "Zed Agent".into()
+ fn empty_state_headline(&self) -> &'static str {
+ "Welcome to the Agent Panel"
}
- fn empty_state_headline(&self) -> SharedString {
- self.name()
- }
-
- fn empty_state_message(&self) -> SharedString {
- "".into()
+ fn empty_state_message(&self) -> &'static str {
+ ""
}
fn logo(&self) -> ui::IconName {
@@ -48,7 +44,7 @@ impl AgentServer for NativeAgentServer {
project: &Entity,
cx: &mut App,
) -> Task>> {
- log::debug!(
+ log::info!(
"NativeAgentServer::connect called for path: {:?}",
_root_dir
);
@@ -67,7 +63,7 @@ impl AgentServer for NativeAgentServer {
// Create the connection wrapper
let connection = NativeAgentConnection(agent);
- log::debug!("NativeAgentServer connection established successfully");
+ log::info!("NativeAgentServer connection established successfully");
Ok(Rc::new(connection) as Rc)
})
diff --git a/crates/agent2/src/tests/mod.rs b/crates/agent2/src/tests/mod.rs
index fbeee46a48..3bd1be497e 100644
--- a/crates/agent2/src/tests/mod.rs
+++ b/crates/agent2/src/tests/mod.rs
@@ -1,40 +1,30 @@
use super::*;
use acp_thread::{AgentConnection, AgentModelGroupName, AgentModelList, UserMessageId};
+use action_log::ActionLog;
use agent_client_protocol::{self as acp};
use agent_settings::AgentProfileId;
use anyhow::Result;
use client::{Client, UserStore};
-use cloud_llm_client::CompletionIntent;
-use collections::IndexMap;
-use context_server::{ContextServer, ContextServerCommand, ContextServerId};
use fs::{FakeFs, Fs};
-use futures::{
- StreamExt,
- channel::{
- mpsc::{self, UnboundedReceiver},
- oneshot,
- },
-};
+use futures::{StreamExt, channel::mpsc::UnboundedReceiver};
use gpui::{
App, AppContext, Entity, Task, TestAppContext, UpdateGlobal, http_client::FakeHttpClient,
};
use indoc::indoc;
use language_model::{
LanguageModel, LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelId,
- LanguageModelProviderName, LanguageModelRegistry, LanguageModelRequest,
- LanguageModelRequestMessage, LanguageModelToolResult, LanguageModelToolSchemaFormat,
- LanguageModelToolUse, MessageContent, Role, StopReason, fake_provider::FakeLanguageModel,
+ LanguageModelProviderName, LanguageModelRegistry, LanguageModelRequestMessage,
+ LanguageModelToolResult, LanguageModelToolUse, MessageContent, Role, StopReason,
+ fake_provider::FakeLanguageModel,
};
use pretty_assertions::assert_eq;
-use project::{
- Project, context_server_store::ContextServerStore, project_settings::ProjectSettings,
-};
+use project::Project;
use prompt_store::ProjectContext;
use reqwest_client::ReqwestClient;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use serde_json::json;
-use settings::{Settings, SettingsStore};
+use settings::SettingsStore;
use std::{path::Path, rc::Rc, sync::Arc, time::Duration};
use util::path;
@@ -42,22 +32,17 @@ mod test_tools;
use test_tools::*;
#[gpui::test]
+#[ignore = "can't run on CI yet"]
async fn test_echo(cx: &mut TestAppContext) {
- let ThreadTest { model, thread, .. } = setup(cx, TestModel::Fake).await;
- let fake_model = model.as_fake();
+ let ThreadTest { thread, .. } = setup(cx, TestModel::Sonnet4).await;
let events = thread
.update(cx, |thread, cx| {
thread.send(UserMessageId::new(), ["Testing: Reply with 'Hello'"], cx)
})
- .unwrap();
- cx.run_until_parked();
- fake_model.send_last_completion_stream_text_chunk("Hello");
- fake_model
- .send_last_completion_stream_event(LanguageModelCompletionEvent::Stop(StopReason::EndTurn));
- fake_model.end_last_completion_stream();
-
- let events = events.collect().await;
+ .unwrap()
+ .collect()
+ .await;
thread.update(cx, |thread, _cx| {
assert_eq!(
thread.last_message().unwrap().to_markdown(),
@@ -72,10 +57,9 @@ async fn test_echo(cx: &mut TestAppContext) {
}
#[gpui::test]
-#[cfg_attr(target_os = "windows", ignore)] // TODO: Fix this test on Windows
+#[ignore = "can't run on CI yet"]
async fn test_thinking(cx: &mut TestAppContext) {
- let ThreadTest { model, thread, .. } = setup(cx, TestModel::Fake).await;
- let fake_model = model.as_fake();
+ let ThreadTest { thread, .. } = setup(cx, TestModel::Sonnet4Thinking).await;
let events = thread
.update(cx, |thread, cx| {
@@ -90,18 +74,9 @@ async fn test_thinking(cx: &mut TestAppContext) {
cx,
)
})
- .unwrap();
- cx.run_until_parked();
- fake_model.send_last_completion_stream_event(LanguageModelCompletionEvent::Thinking {
- text: "Think".to_string(),
- signature: None,
- });
- fake_model.send_last_completion_stream_text_chunk("Hello");
- fake_model
- .send_last_completion_stream_event(LanguageModelCompletionEvent::Stop(StopReason::EndTurn));
- fake_model.end_last_completion_stream();
-
- let events = events.collect().await;
+ .unwrap()
+ .collect()
+ .await;
thread.update(cx, |thread, _cx| {
assert_eq!(
thread.last_message().unwrap().to_markdown(),
@@ -235,7 +210,7 @@ async fn test_prompt_caching(cx: &mut TestAppContext) {
let tool_use = LanguageModelToolUse {
id: "tool_1".into(),
- name: EchoTool::name().into(),
+ name: EchoTool.name().into(),
raw_input: json!({"text": "test"}).to_string(),
input: json!({"text": "test"}),
is_input_complete: true,
@@ -248,7 +223,7 @@ async fn test_prompt_caching(cx: &mut TestAppContext) {
let completion = fake_model.pending_completions().pop().unwrap();
let tool_result = LanguageModelToolResult {
tool_use_id: "tool_1".into(),
- tool_name: EchoTool::name().into(),
+ tool_name: EchoTool.name().into(),
is_error: false,
content: "test".into(),
output: Some("test".into()),
@@ -296,7 +271,7 @@ async fn test_prompt_caching(cx: &mut TestAppContext) {
}
#[gpui::test]
-#[cfg_attr(not(feature = "e2e"), ignore)]
+#[ignore = "can't run on CI yet"]
async fn test_basic_tool_calls(cx: &mut TestAppContext) {
let ThreadTest { thread, .. } = setup(cx, TestModel::Sonnet4).await;
@@ -318,7 +293,7 @@ async fn test_basic_tool_calls(cx: &mut TestAppContext) {
// Test a tool calls that's likely to complete *after* streaming stops.
let events = thread
.update(cx, |thread, cx| {
- thread.remove_tool(&EchoTool::name());
+ thread.remove_tool(&AgentTool::name(&EchoTool));
thread.add_tool(DelayTool);
thread.send(
UserMessageId::new(),
@@ -356,7 +331,7 @@ async fn test_basic_tool_calls(cx: &mut TestAppContext) {
}
#[gpui::test]
-#[cfg_attr(not(feature = "e2e"), ignore)]
+#[ignore = "can't run on CI yet"]
async fn test_streaming_tool_calls(cx: &mut TestAppContext) {
let ThreadTest { thread, .. } = setup(cx, TestModel::Sonnet4).await;
@@ -422,7 +397,7 @@ async fn test_tool_authorization(cx: &mut TestAppContext) {
fake_model.send_last_completion_stream_event(LanguageModelCompletionEvent::ToolUse(
LanguageModelToolUse {
id: "tool_id_1".into(),
- name: ToolRequiringPermission::name().into(),
+ name: ToolRequiringPermission.name().into(),
raw_input: "{}".into(),
input: json!({}),
is_input_complete: true,
@@ -431,7 +406,7 @@ async fn test_tool_authorization(cx: &mut TestAppContext) {
fake_model.send_last_completion_stream_event(LanguageModelCompletionEvent::ToolUse(
LanguageModelToolUse {
id: "tool_id_2".into(),
- name: ToolRequiringPermission::name().into(),
+ name: ToolRequiringPermission.name().into(),
raw_input: "{}".into(),
input: json!({}),
is_input_complete: true,
@@ -462,17 +437,17 @@ async fn test_tool_authorization(cx: &mut TestAppContext) {
vec![
language_model::MessageContent::ToolResult(LanguageModelToolResult {
tool_use_id: tool_call_auth_1.tool_call.id.0.to_string().into(),
- tool_name: ToolRequiringPermission::name().into(),
+ tool_name: ToolRequiringPermission.name().into(),
is_error: false,
content: "Allowed".into(),
output: Some("Allowed".into())
}),
language_model::MessageContent::ToolResult(LanguageModelToolResult {
tool_use_id: tool_call_auth_2.tool_call.id.0.to_string().into(),
- tool_name: ToolRequiringPermission::name().into(),
+ tool_name: ToolRequiringPermission.name().into(),
is_error: true,
content: "Permission to run tool denied by user".into(),
- output: Some("Permission to run tool denied by user".into())
+ output: None
})
]
);
@@ -481,7 +456,7 @@ async fn test_tool_authorization(cx: &mut TestAppContext) {
fake_model.send_last_completion_stream_event(LanguageModelCompletionEvent::ToolUse(
LanguageModelToolUse {
id: "tool_id_3".into(),
- name: ToolRequiringPermission::name().into(),
+ name: ToolRequiringPermission.name().into(),
raw_input: "{}".into(),
input: json!({}),
is_input_complete: true,
@@ -503,7 +478,7 @@ async fn test_tool_authorization(cx: &mut TestAppContext) {
vec![language_model::MessageContent::ToolResult(
LanguageModelToolResult {
tool_use_id: tool_call_auth_3.tool_call.id.0.to_string().into(),
- tool_name: ToolRequiringPermission::name().into(),
+ tool_name: ToolRequiringPermission.name().into(),
is_error: false,
content: "Allowed".into(),
output: Some("Allowed".into())
@@ -515,7 +490,7 @@ async fn test_tool_authorization(cx: &mut TestAppContext) {
fake_model.send_last_completion_stream_event(LanguageModelCompletionEvent::ToolUse(
LanguageModelToolUse {
id: "tool_id_4".into(),
- name: ToolRequiringPermission::name().into(),
+ name: ToolRequiringPermission.name().into(),
raw_input: "{}".into(),
input: json!({}),
is_input_complete: true,
@@ -530,7 +505,7 @@ async fn test_tool_authorization(cx: &mut TestAppContext) {
vec![language_model::MessageContent::ToolResult(
LanguageModelToolResult {
tool_use_id: "tool_id_4".into(),
- tool_name: ToolRequiringPermission::name().into(),
+ tool_name: ToolRequiringPermission.name().into(),
is_error: false,
content: "Allowed".into(),
output: Some("Allowed".into())
@@ -582,7 +557,7 @@ async fn test_resume_after_tool_use_limit(cx: &mut TestAppContext) {
cx.run_until_parked();
let tool_use = LanguageModelToolUse {
id: "tool_id_1".into(),
- name: EchoTool::name().into(),
+ name: EchoTool.name().into(),
raw_input: "{}".into(),
input: serde_json::to_value(&EchoToolInput { text: "def".into() }).unwrap(),
is_input_complete: true,
@@ -595,7 +570,7 @@ async fn test_resume_after_tool_use_limit(cx: &mut TestAppContext) {
let completion = fake_model.pending_completions().pop().unwrap();
let tool_result = LanguageModelToolResult {
tool_use_id: "tool_id_1".into(),
- tool_name: EchoTool::name().into(),
+ tool_name: EchoTool.name().into(),
is_error: false,
content: "def".into(),
output: Some("def".into()),
@@ -675,6 +650,15 @@ async fn test_resume_after_tool_use_limit(cx: &mut TestAppContext) {
"}
)
});
+
+ // 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]
@@ -692,14 +676,14 @@ async fn test_send_after_tool_use_limit(cx: &mut TestAppContext) {
let tool_use = LanguageModelToolUse {
id: "tool_id_1".into(),
- name: EchoTool::name().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(),
+ tool_name: EchoTool.name().into(),
is_error: false,
content: "def".into(),
output: Some("def".into()),
@@ -810,7 +794,7 @@ async fn next_tool_call_authorization(
}
#[gpui::test]
-#[cfg_attr(not(feature = "e2e"), ignore)]
+#[ignore = "can't run on CI yet"]
async fn test_concurrent_tool_calls(cx: &mut TestAppContext) {
let ThreadTest { thread, .. } = setup(cx, TestModel::Sonnet4).await;
@@ -876,14 +860,14 @@ async fn test_profiles(cx: &mut TestAppContext) {
"test-1": {
"name": "Test Profile 1",
"tools": {
- EchoTool::name(): true,
- DelayTool::name(): true,
+ EchoTool.name(): true,
+ DelayTool.name(): true,
}
},
"test-2": {
"name": "Test Profile 2",
"tools": {
- InfiniteTool::name(): true,
+ InfiniteTool.name(): true,
}
}
}
@@ -912,7 +896,7 @@ async fn test_profiles(cx: &mut TestAppContext) {
.iter()
.map(|tool| tool.name.clone())
.collect();
- assert_eq!(tool_names, vec![DelayTool::name(), EchoTool::name()]);
+ assert_eq!(tool_names, vec![DelayTool.name(), EchoTool.name()]);
fake_model.end_last_completion_stream();
// Switch to test-2 profile, and verify that it has only the infinite tool.
@@ -931,339 +915,11 @@ async fn test_profiles(cx: &mut TestAppContext) {
.iter()
.map(|tool| tool.name.clone())
.collect();
- assert_eq!(tool_names, vec![InfiniteTool::name()]);
+ assert_eq!(tool_names, vec![InfiniteTool.name()]);
}
#[gpui::test]
-async fn test_mcp_tools(cx: &mut TestAppContext) {
- let ThreadTest {
- model,
- thread,
- context_server_store,
- fs,
- ..
- } = setup(cx, TestModel::Fake).await;
- let fake_model = model.as_fake();
-
- // Override profiles and wait for settings to be loaded.
- fs.insert_file(
- paths::settings_file(),
- json!({
- "agent": {
- "profiles": {
- "test": {
- "name": "Test Profile",
- "enable_all_context_servers": true,
- "tools": {
- EchoTool::name(): true,
- }
- },
- }
- }
- })
- .to_string()
- .into_bytes(),
- )
- .await;
- cx.run_until_parked();
- thread.update(cx, |thread, _| {
- thread.set_profile(AgentProfileId("test".into()))
- });
-
- let mut mcp_tool_calls = setup_context_server(
- "test_server",
- vec![context_server::types::Tool {
- name: "echo".into(),
- description: None,
- input_schema: serde_json::to_value(
- EchoTool.input_schema(LanguageModelToolSchemaFormat::JsonSchema),
- )
- .unwrap(),
- output_schema: None,
- annotations: None,
- }],
- &context_server_store,
- cx,
- );
-
- let events = thread.update(cx, |thread, cx| {
- thread.send(UserMessageId::new(), ["Hey"], cx).unwrap()
- });
- cx.run_until_parked();
-
- // Simulate the model calling the MCP tool.
- let completion = fake_model.pending_completions().pop().unwrap();
- assert_eq!(tool_names_for_completion(&completion), vec!["echo"]);
- fake_model.send_last_completion_stream_event(LanguageModelCompletionEvent::ToolUse(
- LanguageModelToolUse {
- id: "tool_1".into(),
- name: "echo".into(),
- raw_input: json!({"text": "test"}).to_string(),
- input: json!({"text": "test"}),
- is_input_complete: true,
- },
- ));
- fake_model.end_last_completion_stream();
- cx.run_until_parked();
-
- let (tool_call_params, tool_call_response) = mcp_tool_calls.next().await.unwrap();
- assert_eq!(tool_call_params.name, "echo");
- assert_eq!(tool_call_params.arguments, Some(json!({"text": "test"})));
- tool_call_response
- .send(context_server::types::CallToolResponse {
- content: vec![context_server::types::ToolResponseContent::Text {
- text: "test".into(),
- }],
- is_error: None,
- meta: None,
- structured_content: None,
- })
- .unwrap();
- cx.run_until_parked();
-
- assert_eq!(tool_names_for_completion(&completion), vec!["echo"]);
- fake_model.send_last_completion_stream_text_chunk("Done!");
- fake_model.end_last_completion_stream();
- events.collect::>().await;
-
- // Send again after adding the echo tool, ensuring the name collision is resolved.
- let events = thread.update(cx, |thread, cx| {
- thread.add_tool(EchoTool);
- thread.send(UserMessageId::new(), ["Go"], cx).unwrap()
- });
- cx.run_until_parked();
- let completion = fake_model.pending_completions().pop().unwrap();
- assert_eq!(
- tool_names_for_completion(&completion),
- vec!["echo", "test_server_echo"]
- );
- fake_model.send_last_completion_stream_event(LanguageModelCompletionEvent::ToolUse(
- LanguageModelToolUse {
- id: "tool_2".into(),
- name: "test_server_echo".into(),
- raw_input: json!({"text": "mcp"}).to_string(),
- input: json!({"text": "mcp"}),
- is_input_complete: true,
- },
- ));
- fake_model.send_last_completion_stream_event(LanguageModelCompletionEvent::ToolUse(
- LanguageModelToolUse {
- id: "tool_3".into(),
- name: "echo".into(),
- raw_input: json!({"text": "native"}).to_string(),
- input: json!({"text": "native"}),
- is_input_complete: true,
- },
- ));
- fake_model.end_last_completion_stream();
- cx.run_until_parked();
-
- let (tool_call_params, tool_call_response) = mcp_tool_calls.next().await.unwrap();
- assert_eq!(tool_call_params.name, "echo");
- assert_eq!(tool_call_params.arguments, Some(json!({"text": "mcp"})));
- tool_call_response
- .send(context_server::types::CallToolResponse {
- content: vec![context_server::types::ToolResponseContent::Text { text: "mcp".into() }],
- is_error: None,
- meta: None,
- structured_content: None,
- })
- .unwrap();
- cx.run_until_parked();
-
- // Ensure the tool results were inserted with the correct names.
- let completion = fake_model.pending_completions().pop().unwrap();
- assert_eq!(
- completion.messages.last().unwrap().content,
- vec![
- MessageContent::ToolResult(LanguageModelToolResult {
- tool_use_id: "tool_3".into(),
- tool_name: "echo".into(),
- is_error: false,
- content: "native".into(),
- output: Some("native".into()),
- },),
- MessageContent::ToolResult(LanguageModelToolResult {
- tool_use_id: "tool_2".into(),
- tool_name: "test_server_echo".into(),
- is_error: false,
- content: "mcp".into(),
- output: Some("mcp".into()),
- },),
- ]
- );
- fake_model.end_last_completion_stream();
- events.collect::>().await;
-}
-
-#[gpui::test]
-async fn test_mcp_tool_truncation(cx: &mut TestAppContext) {
- let ThreadTest {
- model,
- thread,
- context_server_store,
- fs,
- ..
- } = setup(cx, TestModel::Fake).await;
- let fake_model = model.as_fake();
-
- // Set up a profile with all tools enabled
- fs.insert_file(
- paths::settings_file(),
- json!({
- "agent": {
- "profiles": {
- "test": {
- "name": "Test Profile",
- "enable_all_context_servers": true,
- "tools": {
- EchoTool::name(): true,
- DelayTool::name(): true,
- WordListTool::name(): true,
- ToolRequiringPermission::name(): true,
- InfiniteTool::name(): true,
- }
- },
- }
- }
- })
- .to_string()
- .into_bytes(),
- )
- .await;
- cx.run_until_parked();
-
- thread.update(cx, |thread, _| {
- thread.set_profile(AgentProfileId("test".into()));
- thread.add_tool(EchoTool);
- thread.add_tool(DelayTool);
- thread.add_tool(WordListTool);
- thread.add_tool(ToolRequiringPermission);
- thread.add_tool(InfiniteTool);
- });
-
- // Set up multiple context servers with some overlapping tool names
- let _server1_calls = setup_context_server(
- "xxx",
- vec![
- context_server::types::Tool {
- name: "echo".into(), // Conflicts with native EchoTool
- description: None,
- input_schema: serde_json::to_value(
- EchoTool.input_schema(LanguageModelToolSchemaFormat::JsonSchema),
- )
- .unwrap(),
- output_schema: None,
- annotations: None,
- },
- context_server::types::Tool {
- name: "unique_tool_1".into(),
- description: None,
- input_schema: json!({"type": "object", "properties": {}}),
- output_schema: None,
- annotations: None,
- },
- ],
- &context_server_store,
- cx,
- );
-
- let _server2_calls = setup_context_server(
- "yyy",
- vec![
- context_server::types::Tool {
- name: "echo".into(), // Also conflicts with native EchoTool
- description: None,
- input_schema: serde_json::to_value(
- EchoTool.input_schema(LanguageModelToolSchemaFormat::JsonSchema),
- )
- .unwrap(),
- output_schema: None,
- annotations: None,
- },
- context_server::types::Tool {
- name: "unique_tool_2".into(),
- description: None,
- input_schema: json!({"type": "object", "properties": {}}),
- output_schema: None,
- annotations: None,
- },
- context_server::types::Tool {
- name: "a".repeat(MAX_TOOL_NAME_LENGTH - 2),
- description: None,
- input_schema: json!({"type": "object", "properties": {}}),
- output_schema: None,
- annotations: None,
- },
- context_server::types::Tool {
- name: "b".repeat(MAX_TOOL_NAME_LENGTH - 1),
- description: None,
- input_schema: json!({"type": "object", "properties": {}}),
- output_schema: None,
- annotations: None,
- },
- ],
- &context_server_store,
- cx,
- );
- let _server3_calls = setup_context_server(
- "zzz",
- vec![
- context_server::types::Tool {
- name: "a".repeat(MAX_TOOL_NAME_LENGTH - 2),
- description: None,
- input_schema: json!({"type": "object", "properties": {}}),
- output_schema: None,
- annotations: None,
- },
- context_server::types::Tool {
- name: "b".repeat(MAX_TOOL_NAME_LENGTH - 1),
- description: None,
- input_schema: json!({"type": "object", "properties": {}}),
- output_schema: None,
- annotations: None,
- },
- context_server::types::Tool {
- name: "c".repeat(MAX_TOOL_NAME_LENGTH + 1),
- description: None,
- input_schema: json!({"type": "object", "properties": {}}),
- output_schema: None,
- annotations: None,
- },
- ],
- &context_server_store,
- cx,
- );
-
- thread
- .update(cx, |thread, cx| {
- thread.send(UserMessageId::new(), ["Go"], cx)
- })
- .unwrap();
- cx.run_until_parked();
- let completion = fake_model.pending_completions().pop().unwrap();
- assert_eq!(
- tool_names_for_completion(&completion),
- vec![
- "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
- "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
- "delay",
- "echo",
- "infinite",
- "tool_requiring_permission",
- "unique_tool_1",
- "unique_tool_2",
- "word_list",
- "xxx_echo",
- "y_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
- "yyy_echo",
- "z_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
- ]
- );
-}
-
-#[gpui::test]
-#[cfg_attr(not(feature = "e2e"), ignore)]
+#[ignore = "can't run on CI yet"]
async fn test_cancellation(cx: &mut TestAppContext) {
let ThreadTest { thread, .. } = setup(cx, TestModel::Sonnet4).await;
@@ -1348,7 +1004,6 @@ async fn test_cancellation(cx: &mut TestAppContext) {
}
#[gpui::test]
-#[cfg_attr(target_os = "windows", ignore)] // TODO: Fix this test on Windows
async fn test_in_progress_send_canceled_by_next_send(cx: &mut TestAppContext) {
let ThreadTest { model, thread, .. } = setup(cx, TestModel::Fake).await;
let fake_model = model.as_fake();
@@ -1687,7 +1342,6 @@ async fn test_truncate_second_message(cx: &mut TestAppContext) {
}
#[gpui::test]
-#[cfg_attr(target_os = "windows", ignore)] // TODO: Fix this test on Windows
async fn test_title_generation(cx: &mut TestAppContext) {
let ThreadTest { model, thread, .. } = setup(cx, TestModel::Fake).await;
let fake_model = model.as_fake();
@@ -1715,7 +1369,6 @@ async fn test_title_generation(cx: &mut TestAppContext) {
summary_model.send_last_completion_stream_text_chunk("oodnight Moon");
summary_model.end_last_completion_stream();
send.collect::>().await;
- cx.run_until_parked();
thread.read_with(cx, |thread, _| assert_eq!(thread.title(), "Hello world"));
// Send another message, ensuring no title is generated this time.
@@ -1733,81 +1386,6 @@ async fn test_title_generation(cx: &mut TestAppContext) {
thread.read_with(cx, |thread, _| assert_eq!(thread.title(), "Hello world"));
}
-#[gpui::test]
-async fn test_building_request_with_pending_tools(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(ToolRequiringPermission);
- thread.add_tool(EchoTool);
- thread.send(UserMessageId::new(), ["Hey!"], cx)
- })
- .unwrap();
- cx.run_until_parked();
-
- let permission_tool_use = LanguageModelToolUse {
- id: "tool_id_1".into(),
- name: ToolRequiringPermission::name().into(),
- raw_input: "{}".into(),
- input: json!({}),
- is_input_complete: true,
- };
- let echo_tool_use = LanguageModelToolUse {
- id: "tool_id_2".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_text_chunk("Hi!");
- fake_model.send_last_completion_stream_event(LanguageModelCompletionEvent::ToolUse(
- permission_tool_use,
- ));
- fake_model.send_last_completion_stream_event(LanguageModelCompletionEvent::ToolUse(
- echo_tool_use.clone(),
- ));
- fake_model.end_last_completion_stream();
- cx.run_until_parked();
-
- // Ensure pending tools are skipped when building a request.
- let request = thread
- .read_with(cx, |thread, cx| {
- thread.build_completion_request(CompletionIntent::EditFile, cx)
- })
- .unwrap();
- assert_eq!(
- request.messages[1..],
- vec![
- LanguageModelRequestMessage {
- role: Role::User,
- content: vec!["Hey!".into()],
- cache: true
- },
- LanguageModelRequestMessage {
- role: Role::Assistant,
- content: vec![
- MessageContent::Text("Hi!".into()),
- MessageContent::ToolUse(echo_tool_use.clone())
- ],
- cache: false
- },
- LanguageModelRequestMessage {
- role: Role::User,
- content: vec![MessageContent::ToolResult(LanguageModelToolResult {
- tool_use_id: echo_tool_use.id.clone(),
- tool_name: echo_tool_use.name,
- is_error: false,
- content: "test".into(),
- output: Some("test".into())
- })],
- cache: false
- },
- ],
- );
-}
-
#[gpui::test]
async fn test_agent_connection(cx: &mut TestAppContext) {
cx.update(settings::init);
@@ -1959,7 +1537,7 @@ async fn test_tool_updates_to_completion(cx: &mut TestAppContext) {
fake_model.send_last_completion_stream_event(LanguageModelCompletionEvent::ToolUse(
LanguageModelToolUse {
id: "1".into(),
- name: ThinkingTool::name().into(),
+ name: ThinkingTool.name().into(),
raw_input: input.to_string(),
input,
is_input_complete: false,
@@ -2100,7 +1678,6 @@ async fn test_send_retry_on_error(cx: &mut TestAppContext) {
.unwrap();
cx.run_until_parked();
- fake_model.send_last_completion_stream_text_chunk("Hey,");
fake_model.send_last_completion_stream_error(LanguageModelCompletionError::ServerOverloaded {
provider: LanguageModelProviderName::new("Anthropic"),
retry_after: Some(Duration::from_secs(3)),
@@ -2110,9 +1687,8 @@ async fn test_send_retry_on_error(cx: &mut TestAppContext) {
cx.executor().advance_clock(Duration::from_secs(3));
cx.run_until_parked();
- fake_model.send_last_completion_stream_text_chunk("there!");
+ fake_model.send_last_completion_stream_text_chunk("Hey!");
fake_model.end_last_completion_stream();
- cx.run_until_parked();
let mut retry_events = Vec::new();
while let Some(Ok(event)) = events.next().await {
@@ -2140,94 +1716,12 @@ async fn test_send_retry_on_error(cx: &mut TestAppContext) {
## Assistant
- Hey,
-
- [resume]
-
- ## Assistant
-
- there!
+ Hey!
"}
)
});
}
-#[gpui::test]
-async fn test_send_retry_finishes_tool_calls_on_error(cx: &mut TestAppContext) {
- let ThreadTest { thread, model, .. } = setup(cx, TestModel::Fake).await;
- let fake_model = model.as_fake();
-
- let events = thread
- .update(cx, |thread, cx| {
- thread.set_completion_mode(agent_settings::CompletionMode::Burn, cx);
- thread.add_tool(EchoTool);
- thread.send(UserMessageId::new(), ["Call the echo tool!"], cx)
- })
- .unwrap();
- cx.run_until_parked();
-
- let tool_use_1 = 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_1.clone(),
- ));
- fake_model.send_last_completion_stream_error(LanguageModelCompletionError::ServerOverloaded {
- provider: LanguageModelProviderName::new("Anthropic"),
- retry_after: Some(Duration::from_secs(3)),
- });
- fake_model.end_last_completion_stream();
-
- cx.executor().advance_clock(Duration::from_secs(3));
- let completion = fake_model.pending_completions().pop().unwrap();
- assert_eq!(
- completion.messages[1..],
- vec![
- LanguageModelRequestMessage {
- role: Role::User,
- content: vec!["Call the echo tool!".into()],
- cache: false
- },
- LanguageModelRequestMessage {
- role: Role::Assistant,
- content: vec![language_model::MessageContent::ToolUse(tool_use_1.clone())],
- cache: false
- },
- LanguageModelRequestMessage {
- role: Role::User,
- content: vec![language_model::MessageContent::ToolResult(
- LanguageModelToolResult {
- tool_use_id: tool_use_1.id.clone(),
- tool_name: tool_use_1.name.clone(),
- is_error: false,
- content: "test".into(),
- output: Some("test".into())
- }
- )],
- cache: true
- },
- ]
- );
-
- fake_model.send_last_completion_stream_text_chunk("Done");
- fake_model.end_last_completion_stream();
- cx.run_until_parked();
- events.collect::>().await;
- thread.read_with(cx, |thread, _cx| {
- assert_eq!(
- thread.last_message(),
- Some(Message::Agent(AgentMessage {
- content: vec![AgentMessageContent::Text("Done".into())],
- tool_results: IndexMap::default()
- }))
- );
- })
-}
-
#[gpui::test]
async fn test_send_max_retries_exceeded(cx: &mut TestAppContext) {
let ThreadTest { thread, model, .. } = setup(cx, TestModel::Fake).await;
@@ -2298,12 +1792,12 @@ struct ThreadTest {
model: Arc,
thread: Entity,
project_context: Entity,
- context_server_store: Entity,
fs: Arc,
}
enum TestModel {
Sonnet4,
+ Sonnet4Thinking,
Fake,
}
@@ -2311,6 +1805,7 @@ impl TestModel {
fn id(&self) -> LanguageModelId {
match self {
TestModel::Sonnet4 => LanguageModelId("claude-sonnet-4-latest".into()),
+ TestModel::Sonnet4Thinking => LanguageModelId("claude-sonnet-4-thinking-latest".into()),
TestModel::Fake => unreachable!(),
}
}
@@ -2332,12 +1827,11 @@ async fn setup(cx: &mut TestAppContext, model: TestModel) -> ThreadTest {
"test-profile": {
"name": "Test Profile",
"tools": {
- EchoTool::name(): true,
- DelayTool::name(): true,
- WordListTool::name(): true,
- ToolRequiringPermission::name(): true,
- InfiniteTool::name(): true,
- ThinkingTool::name(): true,
+ EchoTool.name(): true,
+ DelayTool.name(): true,
+ WordListTool.name(): true,
+ ToolRequiringPermission.name(): true,
+ InfiniteTool.name(): true,
}
}
}
@@ -2394,14 +1888,15 @@ async fn setup(cx: &mut TestAppContext, model: TestModel) -> ThreadTest {
.await;
let project_context = cx.new(|_cx| ProjectContext::default());
- let context_server_store = project.read_with(cx, |project, _| project.context_server_store());
let context_server_registry =
- cx.new(|cx| ContextServerRegistry::new(context_server_store.clone(), cx));
+ cx.new(|cx| ContextServerRegistry::new(project.read(cx).context_server_store(), cx));
+ let action_log = cx.new(|_| ActionLog::new(project.clone()));
let thread = cx.new(|cx| {
Thread::new(
project,
project_context.clone(),
context_server_registry,
+ action_log,
templates,
Some(model.clone()),
cx,
@@ -2411,7 +1906,6 @@ async fn setup(cx: &mut TestAppContext, model: TestModel) -> ThreadTest {
model,
thread,
project_context,
- context_server_store,
fs,
}
}
@@ -2446,89 +1940,3 @@ fn watch_settings(fs: Arc, cx: &mut App) {
})
.detach();
}
-
-fn tool_names_for_completion(completion: &LanguageModelRequest) -> Vec {
- completion
- .tools
- .iter()
- .map(|tool| tool.name.clone())
- .collect()
-}
-
-fn setup_context_server(
- name: &'static str,
- tools: Vec,
- context_server_store: &Entity,
- cx: &mut TestAppContext,
-) -> mpsc::UnboundedReceiver<(
- context_server::types::CallToolParams,
- oneshot::Sender,
-)> {
- cx.update(|cx| {
- let mut settings = ProjectSettings::get_global(cx).clone();
- settings.context_servers.insert(
- name.into(),
- project::project_settings::ContextServerSettings::Custom {
- enabled: true,
- command: ContextServerCommand {
- path: "somebinary".into(),
- args: Vec::new(),
- env: None,
- },
- },
- );
- ProjectSettings::override_global(settings, cx);
- });
-
- let (mcp_tool_calls_tx, mcp_tool_calls_rx) = mpsc::unbounded();
- let fake_transport = context_server::test::create_fake_transport(name, cx.executor())
- .on_request::(move |_params| async move {
- context_server::types::InitializeResponse {
- protocol_version: context_server::types::ProtocolVersion(
- context_server::types::LATEST_PROTOCOL_VERSION.to_string(),
- ),
- server_info: context_server::types::Implementation {
- name: name.into(),
- version: "1.0.0".to_string(),
- },
- capabilities: context_server::types::ServerCapabilities {
- tools: Some(context_server::types::ToolsCapabilities {
- list_changed: Some(true),
- }),
- ..Default::default()
- },
- meta: None,
- }
- })
- .on_request::(move |_params| {
- let tools = tools.clone();
- async move {
- context_server::types::ListToolsResponse {
- tools,
- next_cursor: None,
- meta: None,
- }
- }
- })
- .on_request::(move |params| {
- let mcp_tool_calls_tx = mcp_tool_calls_tx.clone();
- async move {
- let (response_tx, response_rx) = oneshot::channel();
- mcp_tool_calls_tx
- .unbounded_send((params, response_tx))
- .unwrap();
- response_rx.await.unwrap()
- }
- });
- context_server_store.update(cx, |store, cx| {
- store.start_server(
- Arc::new(ContextServer::new(
- ContextServerId(name.into()),
- Arc::new(fake_transport),
- )),
- cx,
- );
- });
- cx.run_until_parked();
- mcp_tool_calls_rx
-}
diff --git a/crates/agent2/src/tests/test_tools.rs b/crates/agent2/src/tests/test_tools.rs
index 27be7b6ac3..cbff44cedf 100644
--- a/crates/agent2/src/tests/test_tools.rs
+++ b/crates/agent2/src/tests/test_tools.rs
@@ -16,11 +16,11 @@ impl AgentTool for EchoTool {
type Input = EchoToolInput;
type Output = String;
- fn name() -> &'static str {
- "echo"
+ fn name(&self) -> SharedString {
+ "echo".into()
}
- fn kind() -> acp::ToolKind {
+ fn kind(&self) -> acp::ToolKind {
acp::ToolKind::Other
}
@@ -51,8 +51,8 @@ impl AgentTool for DelayTool {
type Input = DelayToolInput;
type Output = String;
- fn name() -> &'static str {
- "delay"
+ fn name(&self) -> SharedString {
+ "delay".into()
}
fn initial_title(&self, input: Result) -> SharedString {
@@ -63,7 +63,7 @@ impl AgentTool for DelayTool {
}
}
- fn kind() -> acp::ToolKind {
+ fn kind(&self) -> acp::ToolKind {
acp::ToolKind::Other
}
@@ -92,11 +92,11 @@ impl AgentTool for ToolRequiringPermission {
type Input = ToolRequiringPermissionInput;
type Output = String;
- fn name() -> &'static str {
- "tool_requiring_permission"
+ fn name(&self) -> SharedString {
+ "tool_requiring_permission".into()
}
- fn kind() -> acp::ToolKind {
+ fn kind(&self) -> acp::ToolKind {
acp::ToolKind::Other
}
@@ -127,11 +127,11 @@ impl AgentTool for InfiniteTool {
type Input = InfiniteToolInput;
type Output = String;
- fn name() -> &'static str {
- "infinite"
+ fn name(&self) -> SharedString {
+ "infinite".into()
}
- fn kind() -> acp::ToolKind {
+ fn kind(&self) -> acp::ToolKind {
acp::ToolKind::Other
}
@@ -178,11 +178,11 @@ impl AgentTool for WordListTool {
type Input = WordListInput;
type Output = String;
- fn name() -> &'static str {
- "word_list"
+ fn name(&self) -> SharedString {
+ "word_list".into()
}
- fn kind() -> acp::ToolKind {
+ fn kind(&self) -> acp::ToolKind {
acp::ToolKind::Other
}
diff --git a/crates/agent2/src/thread.rs b/crates/agent2/src/thread.rs
index 97ea1caf1d..6f560cd390 100644
--- a/crates/agent2/src/thread.rs
+++ b/crates/agent2/src/thread.rs
@@ -9,15 +9,15 @@ use action_log::ActionLog;
use agent::thread::{GitState, ProjectSnapshot, WorktreeSnapshot};
use agent_client_protocol as acp;
use agent_settings::{
- AgentProfileId, AgentProfileSettings, AgentSettings, CompletionMode,
- SUMMARIZE_THREAD_DETAILED_PROMPT, SUMMARIZE_THREAD_PROMPT,
+ AgentProfileId, AgentSettings, CompletionMode, SUMMARIZE_THREAD_DETAILED_PROMPT,
+ SUMMARIZE_THREAD_PROMPT,
};
use anyhow::{Context as _, Result, anyhow};
use assistant_tool::adapt_schema_to_format;
use chrono::{DateTime, Utc};
use client::{ModelRequestUsage, RequestUsage};
use cloud_llm_client::{CompletionIntent, CompletionRequestStatus, UsageLimit};
-use collections::{HashMap, HashSet, IndexMap};
+use collections::{HashMap, IndexMap};
use fs::Fs;
use futures::{
FutureExt,
@@ -45,19 +45,17 @@ use schemars::{JsonSchema, Schema};
use serde::{Deserialize, Serialize};
use settings::{Settings, update_settings_file};
use smol::stream::StreamExt;
-use std::fmt::Write;
use std::{
collections::BTreeMap,
- ops::RangeInclusive,
path::Path,
sync::Arc,
time::{Duration, Instant},
};
-use util::{ResultExt, debug_panic, markdown::MarkdownCodeBlock};
+use std::{fmt::Write, ops::Range};
+use util::{ResultExt, markdown::MarkdownCodeBlock};
use uuid::Uuid;
const TOOL_CANCELED_MESSAGE: &str = "Tool canceled by user";
-pub const MAX_TOOL_NAME_LENGTH: usize = 64;
/// The ID of the user prompt that initiated a request.
///
@@ -123,7 +121,7 @@ impl Message {
match self {
Message::User(message) => message.to_markdown(),
Message::Agent(message) => message.to_markdown(),
- Message::Resume => "[resume]\n".into(),
+ Message::Resume => "[resumed after tool use limit was reached]".into(),
}
}
@@ -188,7 +186,6 @@ impl UserMessage {
const OPEN_FILES_TAG: &str = "";
const OPEN_DIRECTORIES_TAG: &str = "";
const OPEN_SYMBOLS_TAG: &str = "";
- const OPEN_SELECTIONS_TAG: &str = "";
const OPEN_THREADS_TAG: &str = "";
const OPEN_FETCH_TAG: &str = "";
const OPEN_RULES_TAG: &str =
@@ -197,7 +194,6 @@ impl UserMessage {
let mut file_context = OPEN_FILES_TAG.to_string();
let mut directory_context = OPEN_DIRECTORIES_TAG.to_string();
let mut symbol_context = OPEN_SYMBOLS_TAG.to_string();
- let mut selection_context = OPEN_SELECTIONS_TAG.to_string();
let mut thread_context = OPEN_THREADS_TAG.to_string();
let mut fetch_context = OPEN_FETCH_TAG.to_string();
let mut rules_context = OPEN_RULES_TAG.to_string();
@@ -214,7 +210,7 @@ impl UserMessage {
match uri {
MentionUri::File { abs_path } => {
write!(
- &mut file_context,
+ &mut symbol_context,
"\n{}",
MarkdownCodeBlock {
tag: &codeblock_tag(abs_path, None),
@@ -223,19 +219,17 @@ impl UserMessage {
)
.ok();
}
- MentionUri::PastedImage => {
- debug_panic!("pasted image URI should not be used in mention content")
- }
MentionUri::Directory { .. } => {
write!(&mut directory_context, "\n{}\n", content).ok();
}
MentionUri::Symbol {
- abs_path: path,
- line_range,
- ..
+ path, line_range, ..
+ }
+ | MentionUri::Selection {
+ path, line_range, ..
} => {
write!(
- &mut symbol_context,
+ &mut rules_context,
"\n{}",
MarkdownCodeBlock {
tag: &codeblock_tag(path, Some(line_range)),
@@ -244,24 +238,6 @@ impl UserMessage {
)
.ok();
}
- MentionUri::Selection {
- abs_path: path,
- line_range,
- ..
- } => {
- write!(
- &mut selection_context,
- "\n{}",
- MarkdownCodeBlock {
- tag: &codeblock_tag(
- path.as_deref().unwrap_or("Untitled".as_ref()),
- Some(line_range)
- ),
- text: content
- }
- )
- .ok();
- }
MentionUri::Thread { .. } => {
write!(&mut thread_context, "\n{}\n", content).ok();
}
@@ -314,13 +290,6 @@ impl UserMessage {
.push(language_model::MessageContent::Text(symbol_context));
}
- if selection_context.len() > OPEN_SELECTIONS_TAG.len() {
- selection_context.push_str("\n");
- message
- .content
- .push(language_model::MessageContent::Text(selection_context));
- }
-
if thread_context.len() > OPEN_THREADS_TAG.len() {
thread_context.push_str("\n");
message
@@ -356,7 +325,7 @@ impl UserMessage {
}
}
-fn codeblock_tag(full_path: &Path, line_range: Option<&RangeInclusive>) -> String {
+fn codeblock_tag(full_path: &Path, line_range: Option<&Range>) -> String {
let mut result = String::new();
if let Some(extension) = full_path.extension().and_then(|ext| ext.to_str()) {
@@ -366,10 +335,10 @@ fn codeblock_tag(full_path: &Path, line_range: Option<&RangeInclusive>) ->
let _ = write!(result, "{}", full_path.display());
if let Some(range) = line_range {
- if range.start() == range.end() {
- let _ = write!(result, ":{}", range.start() + 1);
+ if range.start == range.end {
+ let _ = write!(result, ":{}", range.start + 1);
} else {
- let _ = write!(result, ":{}-{}", range.start() + 1, range.end() + 1);
+ let _ = write!(result, ":{}-{}", range.start + 1, range.end + 1);
}
}
@@ -448,33 +417,24 @@ impl AgentMessage {
cache: false,
};
for chunk in &self.content {
- match chunk {
+ let chunk = match chunk {
AgentMessageContent::Text(text) => {
- assistant_message
- .content
- .push(language_model::MessageContent::Text(text.clone()));
+ language_model::MessageContent::Text(text.clone())
}
AgentMessageContent::Thinking { text, signature } => {
- assistant_message
- .content
- .push(language_model::MessageContent::Thinking {
- text: text.clone(),
- signature: signature.clone(),
- });
- }
- AgentMessageContent::RedactedThinking(value) => {
- assistant_message.content.push(
- language_model::MessageContent::RedactedThinking(value.clone()),
- );
- }
- AgentMessageContent::ToolUse(tool_use) => {
- if self.tool_results.contains_key(&tool_use.id) {
- assistant_message
- .content
- .push(language_model::MessageContent::ToolUse(tool_use.clone()));
+ language_model::MessageContent::Thinking {
+ text: text.clone(),
+ signature: signature.clone(),
}
}
+ AgentMessageContent::RedactedThinking(value) => {
+ language_model::MessageContent::RedactedThinking(value.clone())
+ }
+ AgentMessageContent::ToolUse(value) => {
+ language_model::MessageContent::ToolUse(value.clone())
+ }
};
+ assistant_message.content.push(chunk);
}
let mut user_message = LanguageModelRequestMessage {
@@ -527,6 +487,7 @@ pub enum ThreadEvent {
ToolCall(acp::ToolCall),
ToolCallUpdate(acp_thread::ToolCallUpdate),
ToolCallAuthorization(ToolCallAuthorization),
+ TitleUpdate(SharedString),
Retry(acp_thread::RetryStatus),
Stop(acp::StopReason),
}
@@ -553,7 +514,6 @@ pub struct Thread {
prompt_id: PromptId,
updated_at: DateTime,
title: Option,
- pending_title_generation: Option>,
summary: Option,
messages: Vec,
completion_mode: CompletionMode,
@@ -575,40 +535,26 @@ pub struct Thread {
templates: Arc,
model: Option>,
summarization_model: Option>,
- prompt_capabilities_tx: watch::Sender,
- pub(crate) prompt_capabilities_rx: watch::Receiver,
pub(crate) project: Entity,
pub(crate) action_log: Entity,
}
impl Thread {
- fn prompt_capabilities(model: Option<&dyn LanguageModel>) -> acp::PromptCapabilities {
- let image = model.map_or(true, |model| model.supports_images());
- acp::PromptCapabilities {
- image,
- audio: false,
- embedded_context: true,
- }
- }
-
pub fn new(
project: Entity,
project_context: Entity,
context_server_registry: Entity,
+ action_log: Entity,
templates: Arc,
model: Option>,
cx: &mut Context,
) -> Self {
let profile_id = AgentSettings::get_global(cx).default_profile.clone();
- let action_log = cx.new(|_cx| ActionLog::new(project.clone()));
- let (prompt_capabilities_tx, prompt_capabilities_rx) =
- watch::channel(Self::prompt_capabilities(model.as_deref()));
Self {
id: acp::SessionId(uuid::Uuid::new_v4().to_string().into()),
prompt_id: PromptId::new(),
updated_at: Utc::now(),
title: None,
- pending_title_generation: None,
summary: None,
messages: Vec::new(),
completion_mode: AgentSettings::get_global(cx).preferred_completion_mode,
@@ -630,8 +576,6 @@ impl Thread {
templates,
model,
summarization_model: None,
- prompt_capabilities_tx,
- prompt_capabilities_rx,
project,
action_log,
}
@@ -682,20 +626,7 @@ impl Thread {
stream: &ThreadEventStream,
cx: &mut Context,
) {
- let tool = self.tools.get(tool_use.name.as_ref()).cloned().or_else(|| {
- self.context_server_registry
- .read(cx)
- .servers()
- .find_map(|(_, tools)| {
- if let Some(tool) = tools.get(tool_use.name.as_ref()) {
- Some(tool.clone())
- } else {
- None
- }
- })
- });
-
- let Some(tool) = tool else {
+ let Some(tool) = self.tools.get(tool_use.name.as_ref()) else {
stream
.0
.unbounded_send(Ok(ThreadEvent::ToolCall(acp::ToolCall {
@@ -732,17 +663,7 @@ impl Thread {
stream.update_tool_call_fields(
&tool_use.id,
acp::ToolCallUpdateFields {
- status: Some(
- tool_result
- .as_ref()
- .map_or(acp::ToolCallStatus::Failed, |result| {
- if result.is_error {
- acp::ToolCallStatus::Failed
- } else {
- acp::ToolCallStatus::Completed
- }
- }),
- ),
+ status: Some(acp::ToolCallStatus::Completed),
raw_output: output,
..Default::default()
},
@@ -775,8 +696,6 @@ impl Thread {
.or_else(|| registry.default_model())
.map(|model| model.model)
});
- let (prompt_capabilities_tx, prompt_capabilities_rx) =
- watch::channel(Self::prompt_capabilities(model.as_deref()));
Self {
id,
@@ -786,7 +705,6 @@ impl Thread {
} else {
Some(db_thread.title.clone())
},
- pending_title_generation: None,
summary: db_thread.detailed_summary,
messages: db_thread.messages,
completion_mode: db_thread.completion_mode.unwrap_or_default(),
@@ -806,8 +724,6 @@ impl Thread {
project,
action_log,
updated_at: db_thread.updated_at,
- prompt_capabilities_tx,
- prompt_capabilities_rx,
}
}
@@ -975,12 +891,10 @@ impl Thread {
pub fn set_model(&mut self, model: Arc, cx: &mut Context) {
let old_usage = self.latest_token_usage();
self.model = Some(model);
- let new_caps = Self::prompt_capabilities(self.model.as_deref());
let new_usage = self.latest_token_usage();
if old_usage != new_usage {
cx.emit(TokenUsageUpdated(new_usage));
}
- self.prompt_capabilities_tx.send(new_caps).log_err();
cx.notify()
}
@@ -1043,11 +957,11 @@ impl Thread {
));
self.add_tool(TerminalTool::new(self.project.clone(), cx));
self.add_tool(ThinkingTool);
- self.add_tool(WebSearchTool);
+ self.add_tool(WebSearchTool); // TODO: Enable this only if it's a zed model.
}
- pub fn add_tool(&mut self, tool: T) {
- self.tools.insert(T::name().into(), tool.erase());
+ pub fn add_tool(&mut self, tool: impl AgentTool) {
+ self.tools.insert(tool.name(), tool.erase());
}
pub fn remove_tool(&mut self, name: &str) -> bool {
@@ -1116,10 +1030,15 @@ impl Thread {
&mut self,
cx: &mut Context,
) -> Result>> {
+ anyhow::ensure!(
+ self.tool_use_limit_reached,
+ "can only resume after tool use limit is reached"
+ );
+
self.messages.push(Message::Resume);
cx.notify();
- log::debug!("Total messages in thread: {}", self.messages.len());
+ log::info!("Total messages in thread: {}", self.messages.len());
self.run_turn(cx)
}
@@ -1137,7 +1056,7 @@ impl Thread {
{
let model = self.model().context("No language model configured")?;
- log::info!("Thread::send called with model: {}", model.name().0);
+ log::info!("Thread::send called with model: {:?}", model.name());
self.advance_prompt_id();
let content = content.into_iter().map(Into::into).collect::>();
@@ -1147,7 +1066,7 @@ impl Thread {
.push(Message::User(UserMessage { id, content }));
cx.notify();
- log::debug!("Total messages in thread: {}", self.messages.len());
+ log::info!("Total messages in thread: {}", self.messages.len());
self.run_turn(cx)
}
@@ -1158,10 +1077,6 @@ impl Thread {
self.cancel(cx);
let model = self.model.clone().context("No language model configured")?;
- let profile = AgentSettings::get_global(cx)
- .profiles
- .get(&self.profile_id)
- .context("Profile not found")?;
let (events_tx, events_rx) = mpsc::unbounded::>();
let event_stream = ThreadEventStream(events_tx);
let message_ix = self.messages.len().saturating_sub(1);
@@ -1169,16 +1084,49 @@ impl Thread {
self.summary = None;
self.running_turn = Some(RunningTurn {
event_stream: event_stream.clone(),
- tools: self.enabled_tools(profile, &model, cx),
_task: cx.spawn(async move |this, cx| {
- log::debug!("Starting agent turn execution");
+ log::info!("Starting agent turn execution");
+ let mut update_title = None;
+ let turn_result: Result<()> = async {
+ let mut intent = CompletionIntent::UserPrompt;
+ loop {
+ Self::stream_completion(&this, &model, intent, &event_stream, cx).await?;
- let turn_result = Self::run_turn_internal(&this, model, &event_stream, cx).await;
+ let mut end_turn = true;
+ this.update(cx, |this, cx| {
+ // Generate title if needed.
+ if this.title.is_none() && update_title.is_none() {
+ update_title = Some(this.update_title(&event_stream, cx));
+ }
+
+ // End the turn if the model didn't use tools.
+ let message = this.pending_message.as_ref();
+ end_turn =
+ message.map_or(true, |message| message.tool_results.is_empty());
+ this.flush_pending_message(cx);
+ })?;
+
+ if this.read_with(cx, |this, _| this.tool_use_limit_reached)? {
+ log::info!("Tool use limit reached, completing turn");
+ return Err(language_model::ToolUseLimitReachedError.into());
+ } else if end_turn {
+ log::info!("No tool uses found, completing turn");
+ return Ok(());
+ } else {
+ intent = CompletionIntent::ToolResults;
+ }
+ }
+ }
+ .await;
_ = this.update(cx, |this, cx| this.flush_pending_message(cx));
+ if let Some(update_title) = update_title {
+ update_title.await.context("update title failed").log_err();
+ }
+
match turn_result {
Ok(()) => {
- log::debug!("Turn execution completed");
+ log::info!("Turn execution completed");
event_stream.send_stop(acp::StopReason::EndTurn);
}
Err(error) => {
@@ -1204,18 +1152,20 @@ impl Thread {
Ok(events_rx)
}
- async fn run_turn_internal(
+ async fn stream_completion(
this: &WeakEntity,
- model: Arc,
+ model: &Arc,
+ completion_intent: CompletionIntent,
event_stream: &ThreadEventStream,
cx: &mut AsyncApp,
) -> Result<()> {
- let mut attempt = 0;
- let mut intent = CompletionIntent::UserPrompt;
- loop {
- let request =
- this.update(cx, |this, cx| this.build_completion_request(intent, cx))??;
+ log::debug!("Stream completion started successfully");
+ let request = this.update(cx, |this, cx| {
+ this.build_completion_request(completion_intent, cx)
+ })??;
+ let mut attempt = None;
+ 'retry: loop {
telemetry::event!(
"Agent Thread Completion",
thread_id = this.read_with(cx, |this, _| this.id.to_string())?,
@@ -1225,31 +1175,75 @@ impl Thread {
attempt
);
- log::debug!("Calling model.stream_completion, attempt {}", attempt);
+ log::info!(
+ "Calling model.stream_completion, attempt {}",
+ attempt.unwrap_or(0)
+ );
let mut events = model
- .stream_completion(request, cx)
+ .stream_completion(request.clone(), cx)
.await
.map_err(|error| anyhow!(error))?;
let mut tool_results = FuturesUnordered::new();
- let mut error = None;
+
while let Some(event) = events.next().await {
- log::trace!("Received completion event: {:?}", event);
match event {
Ok(event) => {
+ log::trace!("Received completion event: {:?}", event);
tool_results.extend(this.update(cx, |this, cx| {
- this.handle_completion_event(event, event_stream, cx)
+ this.handle_streamed_completion_event(event, event_stream, cx)
})??);
}
- Err(err) => {
- error = Some(err);
- break;
+ Err(error) => {
+ let completion_mode =
+ this.read_with(cx, |thread, _cx| thread.completion_mode())?;
+ if completion_mode == CompletionMode::Normal {
+ return Err(anyhow!(error))?;
+ }
+
+ let Some(strategy) = Self::retry_strategy_for(&error) else {
+ return Err(anyhow!(error))?;
+ };
+
+ let max_attempts = match &strategy {
+ RetryStrategy::ExponentialBackoff { max_attempts, .. } => *max_attempts,
+ RetryStrategy::Fixed { max_attempts, .. } => *max_attempts,
+ };
+
+ let attempt = attempt.get_or_insert(0u8);
+
+ *attempt += 1;
+
+ let attempt = *attempt;
+ if attempt > max_attempts {
+ return Err(anyhow!(error))?;
+ }
+
+ let delay = match &strategy {
+ RetryStrategy::ExponentialBackoff { initial_delay, .. } => {
+ let delay_secs =
+ initial_delay.as_secs() * 2u64.pow((attempt - 1) as u32);
+ Duration::from_secs(delay_secs)
+ }
+ RetryStrategy::Fixed { delay, .. } => *delay,
+ };
+ log::debug!("Retry attempt {attempt} with delay {delay:?}");
+
+ event_stream.send_retry(acp_thread::RetryStatus {
+ last_error: error.to_string().into(),
+ attempt: attempt as usize,
+ max_attempts: max_attempts as usize,
+ started_at: Instant::now(),
+ duration: delay,
+ });
+
+ cx.background_executor().timer(delay).await;
+ continue 'retry;
}
}
}
- let end_turn = tool_results.is_empty();
while let Some(tool_result) = tool_results.next().await {
- log::debug!("Tool finished {:?}", tool_result);
+ log::info!("Tool finished {:?}", tool_result);
event_stream.update_tool_call_fields(
&tool_result.tool_use_id,
@@ -1270,83 +1264,31 @@ impl Thread {
})?;
}
- this.update(cx, |this, cx| {
- this.flush_pending_message(cx);
- if this.title.is_none() && this.pending_title_generation.is_none() {
- this.generate_title(cx);
- }
- })?;
-
- if let Some(error) = error {
- attempt += 1;
- let retry =
- this.update(cx, |this, _| this.handle_completion_error(error, attempt))??;
- let timer = cx.background_executor().timer(retry.duration);
- event_stream.send_retry(retry);
- timer.await;
- this.update(cx, |this, _cx| {
- if let Some(Message::Agent(message)) = this.messages.last() {
- if message.tool_results.is_empty() {
- intent = CompletionIntent::UserPrompt;
- this.messages.push(Message::Resume);
- }
- }
- })?;
- } else if this.read_with(cx, |this, _| this.tool_use_limit_reached)? {
- return Err(language_model::ToolUseLimitReachedError.into());
- } else if end_turn {
- return Ok(());
- } else {
- intent = CompletionIntent::ToolResults;
- attempt = 0;
- }
+ return Ok(());
}
}
- fn handle_completion_error(
- &mut self,
- error: LanguageModelCompletionError,
- attempt: u8,
- ) -> Result {
- if self.completion_mode == CompletionMode::Normal {
- return Err(anyhow!(error));
+ pub fn build_system_message(&self, cx: &App) -> LanguageModelRequestMessage {
+ log::debug!("Building system message");
+ let prompt = SystemPromptTemplate {
+ project: self.project_context.read(cx),
+ available_tools: self.tools.keys().cloned().collect(),
}
-
- let Some(strategy) = Self::retry_strategy_for(&error) else {
- return Err(anyhow!(error));
- };
-
- let max_attempts = match &strategy {
- RetryStrategy::ExponentialBackoff { max_attempts, .. } => *max_attempts,
- RetryStrategy::Fixed { max_attempts, .. } => *max_attempts,
- };
-
- if attempt > max_attempts {
- return Err(anyhow!(error));
+ .render(&self.templates)
+ .context("failed to build system prompt")
+ .expect("Invalid template");
+ log::debug!("System message built");
+ LanguageModelRequestMessage {
+ role: Role::System,
+ content: vec![prompt.into()],
+ cache: true,
}
-
- let delay = match &strategy {
- RetryStrategy::ExponentialBackoff { initial_delay, .. } => {
- let delay_secs = initial_delay.as_secs() * 2u64.pow((attempt - 1) as u32);
- Duration::from_secs(delay_secs)
- }
- RetryStrategy::Fixed { delay, .. } => *delay,
- };
- log::debug!("Retry attempt {attempt} with delay {delay:?}");
-
- Ok(acp_thread::RetryStatus {
- last_error: error.to_string().into(),
- attempt: attempt as usize,
- max_attempts: max_attempts as usize,
- started_at: Instant::now(),
- duration: delay,
- })
}
/// A helper method that's called on every streamed completion event.
/// Returns an optional tool result task, which the main agentic loop will
/// send back to the model when it resolves.
- fn handle_completion_event(
+ fn handle_streamed_completion_event(
&mut self,
event: LanguageModelCompletionEvent,
event_stream: &ThreadEventStream,
@@ -1477,7 +1419,7 @@ impl Thread {
) -> Option> {
cx.notify();
- let tool = self.tool(tool_use.name.as_ref());
+ let tool = self.tools.get(tool_use.name.as_ref()).cloned();
let mut title = SharedString::from(&tool_use.name);
let mut kind = acp::ToolKind::Other;
if let Some(tool) = tool.as_ref() {
@@ -1541,7 +1483,7 @@ impl Thread {
});
let supports_images = self.model().is_some_and(|model| model.supports_images());
let tool_result = tool.run(tool_use.input, tool_event_stream, cx);
- log::debug!("Running tool {}", tool_use.name);
+ log::info!("Running tool {}", tool_use.name);
Some(cx.foreground_executor().spawn(async move {
let tool_result = tool_result.await.and_then(|output| {
if let LanguageModelToolResultContent::Image(_) = &output.llm_output
@@ -1567,7 +1509,7 @@ impl Thread {
tool_name: tool_use.name,
is_error: true,
content: LanguageModelToolResultContent::Text(Arc::from(error.to_string())),
- output: Some(error.to_string().into()),
+ output: None,
},
}
}))
@@ -1653,7 +1595,7 @@ impl Thread {
summary.extend(lines.next());
}
- log::debug!("Setting summary: {}", summary);
+ log::info!("Setting summary: {}", summary);
let summary = SharedString::from(summary);
this.update(cx, |this, cx| {
@@ -1665,15 +1607,19 @@ impl Thread {
})
}
- fn generate_title(&mut self, cx: &mut Context) {
- let Some(model) = self.summarization_model.clone() else {
- return;
- };
-
- log::debug!(
+ fn update_title(
+ &mut self,
+ event_stream: &ThreadEventStream,
+ cx: &mut Context,
+ ) -> Task> {
+ log::info!(
"Generating title with model: {:?}",
self.summarization_model.as_ref().map(|model| model.name())
);
+ let Some(model) = self.summarization_model.clone() else {
+ return Task::ready(Ok(()));
+ };
+ let event_stream = event_stream.clone();
let mut request = LanguageModelRequest {
intent: Some(CompletionIntent::ThreadSummarization),
temperature: AgentSettings::temperature_for_model(&model, cx),
@@ -1689,51 +1635,42 @@ impl Thread {
content: vec![SUMMARIZE_THREAD_PROMPT.into()],
cache: false,
});
- self.pending_title_generation = Some(cx.spawn(async move |this, cx| {
+ cx.spawn(async move |this, cx| {
let mut title = String::new();
-
- let generate = async {
- let mut messages = model.stream_completion(request, cx).await?;
- while let Some(event) = messages.next().await {
- let event = event?;
- let text = match event {
- LanguageModelCompletionEvent::Text(text) => text,
- LanguageModelCompletionEvent::StatusUpdate(
- CompletionRequestStatus::UsageUpdated { amount, limit },
- ) => {
- this.update(cx, |thread, cx| {
- thread.update_model_request_usage(amount, limit, cx);
- })?;
- continue;
- }
- _ => continue,
- };
-
- let mut lines = text.lines();
- title.extend(lines.next());
-
- // Stop if the LLM generated multiple lines.
- if lines.next().is_some() {
- break;
+ let mut messages = model.stream_completion(request, cx).await?;
+ while let Some(event) = messages.next().await {
+ let event = event?;
+ let text = match event {
+ LanguageModelCompletionEvent::Text(text) => text,
+ LanguageModelCompletionEvent::StatusUpdate(
+ CompletionRequestStatus::UsageUpdated { amount, limit },
+ ) => {
+ this.update(cx, |thread, cx| {
+ thread.update_model_request_usage(amount, limit, cx);
+ })?;
+ continue;
}
+ _ => continue,
+ };
+
+ let mut lines = text.lines();
+ title.extend(lines.next());
+
+ // Stop if the LLM generated multiple lines.
+ if lines.next().is_some() {
+ break;
}
- anyhow::Ok(())
- };
-
- if generate.await.context("failed to generate title").is_ok() {
- _ = this.update(cx, |this, cx| this.set_title(title.into(), cx));
}
- _ = this.update(cx, |this, _| this.pending_title_generation = None);
- }));
- }
- pub fn set_title(&mut self, title: SharedString, cx: &mut Context) {
- self.pending_title_generation = None;
- if Some(&title) != self.title.as_ref() {
- self.title = Some(title);
- cx.emit(TitleUpdated);
- cx.notify();
- }
+ log::info!("Setting title: {}", title);
+
+ this.update(cx, |this, cx| {
+ let title = SharedString::from(title);
+ event_stream.send_title_update(title.clone());
+ this.title = Some(title);
+ cx.notify();
+ })
+ })
}
fn last_user_message(&self) -> Option<&UserMessage> {
@@ -1756,10 +1693,6 @@ impl Thread {
return;
};
- if message.content.is_empty() {
- return;
- }
-
for content in &message.content {
let AgentMessageContent::ToolUse(tool_use) = content else {
continue;
@@ -1788,32 +1721,34 @@ impl Thread {
pub(crate) fn build_completion_request(
&self,
completion_intent: CompletionIntent,
- cx: &App,
+ cx: &mut App,
) -> Result {
let model = self.model().context("No language model configured")?;
- let tools = if let Some(turn) = self.running_turn.as_ref() {
- turn.tools
- .iter()
- .filter_map(|(tool_name, tool)| {
- log::trace!("Including tool: {}", tool_name);
- Some(LanguageModelRequestTool {
- name: tool_name.to_string(),
- description: tool.description().to_string(),
- input_schema: tool.input_schema(model.tool_input_format()).log_err()?,
- })
- })
- .collect::>()
- } else {
- Vec::new()
- };
log::debug!("Building completion request");
log::debug!("Completion intent: {:?}", completion_intent);
log::debug!("Completion mode: {:?}", self.completion_mode);
let messages = self.build_request_messages(cx);
- log::debug!("Request will include {} messages", messages.len());
- log::debug!("Request includes {} tools", tools.len());
+ log::info!("Request will include {} messages", messages.len());
+
+ let tools = if let Some(tools) = self.tools(cx).log_err() {
+ tools
+ .filter_map(|tool| {
+ let tool_name = tool.name().to_string();
+ log::trace!("Including tool: {}", tool_name);
+ Some(LanguageModelRequestTool {
+ name: tool_name,
+ description: tool.description().to_string(),
+ input_schema: tool.input_schema(model.tool_input_format()).log_err()?,
+ })
+ })
+ .collect()
+ } else {
+ Vec::new()
+ };
+
+ log::info!("Request includes {} tools", tools.len());
let request = LanguageModelRequest {
thread_id: Some(self.id.to_string()),
@@ -1832,76 +1767,37 @@ impl Thread {
Ok(request)
}
- fn enabled_tools(
- &self,
- profile: &AgentProfileSettings,
- model: &Arc,
- cx: &App,
- ) -> BTreeMap> {
- fn truncate(tool_name: &SharedString) -> SharedString {
- if tool_name.len() > MAX_TOOL_NAME_LENGTH {
- let mut truncated = tool_name.to_string();
- truncated.truncate(MAX_TOOL_NAME_LENGTH);
- truncated.into()
- } else {
- tool_name.clone()
- }
- }
+ fn tools<'a>(&'a self, cx: &'a App) -> Result>> {
+ let model = self.model().context("No language model configured")?;
- let mut tools = self
+ let profile = AgentSettings::get_global(cx)
+ .profiles
+ .get(&self.profile_id)
+ .context("profile not found")?;
+ let provider_id = model.provider_id();
+
+ Ok(self
.tools
.iter()
+ .filter(move |(_, tool)| tool.supported_provider(&provider_id))
.filter_map(|(tool_name, tool)| {
- if tool.supported_provider(&model.provider_id())
- && profile.is_tool_enabled(tool_name)
- {
- Some((truncate(tool_name), tool.clone()))
+ if profile.is_tool_enabled(tool_name) {
+ Some(tool)
} else {
None
}
})
- .collect::>();
-
- let mut context_server_tools = Vec::new();
- let mut seen_tools = tools.keys().cloned().collect::>();
- let mut duplicate_tool_names = HashSet::default();
- for (server_id, server_tools) in self.context_server_registry.read(cx).servers() {
- for (tool_name, tool) in server_tools {
- if profile.is_context_server_tool_enabled(&server_id.0, &tool_name) {
- let tool_name = truncate(tool_name);
- if !seen_tools.insert(tool_name.clone()) {
- duplicate_tool_names.insert(tool_name.clone());
- }
- context_server_tools.push((server_id.clone(), tool_name, tool.clone()));
- }
- }
- }
-
- // When there are duplicate tool names, disambiguate by prefixing them
- // with the server ID. In the rare case there isn't enough space for the
- // disambiguated tool name, keep only the last tool with this name.
- for (server_id, tool_name, tool) in context_server_tools {
- if duplicate_tool_names.contains(&tool_name) {
- let available = MAX_TOOL_NAME_LENGTH.saturating_sub(tool_name.len());
- if available >= 2 {
- let mut disambiguated = server_id.0.to_string();
- disambiguated.truncate(available - 1);
- disambiguated.push('_');
- disambiguated.push_str(&tool_name);
- tools.insert(disambiguated.into(), tool.clone());
- } else {
- tools.insert(tool_name, tool.clone());
- }
- } else {
- tools.insert(tool_name, tool.clone());
- }
- }
-
- tools
- }
-
- fn tool(&self, name: &str) -> Option> {
- self.running_turn.as_ref()?.tools.get(name).cloned()
+ .chain(self.context_server_registry.read(cx).servers().flat_map(
+ |(server_id, tools)| {
+ tools.iter().filter_map(|(tool_name, tool)| {
+ if profile.is_context_server_tool_enabled(&server_id.0, tool_name) {
+ Some(tool)
+ } else {
+ None
+ }
+ })
+ },
+ )))
}
fn build_request_messages(&self, cx: &App) -> Vec {
@@ -1909,31 +1805,23 @@ impl Thread {
"Building request messages from {} thread messages",
self.messages.len()
);
-
- let system_prompt = SystemPromptTemplate {
- project: self.project_context.read(cx),
- available_tools: self.tools.keys().cloned().collect(),
- }
- .render(&self.templates)
- .context("failed to build system prompt")
- .expect("Invalid template");
- let mut messages = vec![LanguageModelRequestMessage {
- role: Role::System,
- content: vec![system_prompt.into()],
- cache: false,
- }];
+ let mut messages = vec![self.build_system_message(cx)];
for message in &self.messages {
messages.extend(message.to_request());
}
- if let Some(last_message) = messages.last_mut() {
- last_message.cache = true;
- }
-
if let Some(message) = self.pending_message.as_ref() {
messages.extend(message.to_request());
}
+ if let Some(last_user_message) = messages
+ .iter_mut()
+ .rev()
+ .find(|message| message.role == Role::User)
+ {
+ last_user_message.cache = true;
+ }
+
messages
}
@@ -2074,8 +1962,6 @@ struct RunningTurn {
/// The current event stream for the running turn. Used to report a final
/// cancellation event if we cancel the turn.
event_stream: ThreadEventStream,
- /// The tools that were enabled for this turn.
- tools: BTreeMap>,
}
impl RunningTurn {
@@ -2089,10 +1975,6 @@ pub struct TokenUsageUpdated(pub Option);
impl EventEmitter for Thread {}
-pub struct TitleUpdated;
-
-impl EventEmitter for Thread {}
-
pub trait AgentTool
where
Self: 'static + Sized,
@@ -2100,7 +1982,7 @@ where
type Input: for<'de> Deserialize<'de> + Serialize + JsonSchema;
type Output: for<'de> Deserialize<'de> + Serialize + Into;
- fn name() -> &'static str;
+ fn name(&self) -> SharedString;
fn description(&self) -> SharedString {
let schema = schemars::schema_for!(Self::Input);
@@ -2112,7 +1994,7 @@ where
)
}
- fn kind() -> acp::ToolKind;
+ fn kind(&self) -> acp::ToolKind;
/// The initial tool title to display. Can be updated during the tool run.
fn initial_title(&self, input: Result) -> SharedString;
@@ -2188,7 +2070,7 @@ where
T: AgentTool,
{
fn name(&self) -> SharedString {
- T::name().into()
+ self.0.name()
}
fn description(&self) -> SharedString {
@@ -2196,7 +2078,7 @@ where
}
fn kind(&self) -> agent_client_protocol::ToolKind {
- T::kind()
+ self.0.kind()
}
fn initial_title(&self, input: serde_json::Value) -> SharedString {
@@ -2250,6 +2132,12 @@ where
struct ThreadEventStream(mpsc::UnboundedSender>);
impl ThreadEventStream {
+ fn send_title_update(&self, text: SharedString) {
+ self.0
+ .unbounded_send(Ok(ThreadEvent::TitleUpdate(text)))
+ .ok();
+ }
+
fn send_user_message(&self, message: &UserMessage) {
self.0
.unbounded_send(Ok(ThreadEvent::UserMessage(message.clone())))
@@ -2469,30 +2357,6 @@ impl ToolCallEventStreamReceiver {
}
}
- pub async fn expect_update_fields(&mut self) -> acp::ToolCallUpdateFields {
- let event = self.0.next().await;
- if let Some(Ok(ThreadEvent::ToolCallUpdate(acp_thread::ToolCallUpdate::UpdateFields(
- update,
- )))) = event
- {
- update.fields
- } else {
- panic!("Expected update fields but got: {:?}", event);
- }
- }
-
- pub async fn expect_diff(&mut self) -> Entity {
- let event = self.0.next().await;
- if let Some(Ok(ThreadEvent::ToolCallUpdate(acp_thread::ToolCallUpdate::UpdateDiff(
- update,
- )))) = event
- {
- update.diff
- } else {
- panic!("Expected diff but got: {:?}", event);
- }
- }
-
pub async fn expect_terminal(&mut self) -> Entity {
let event = self.0.next().await;
if let Some(Ok(ThreadEvent::ToolCallUpdate(acp_thread::ToolCallUpdate::UpdateTerminal(
diff --git a/crates/agent2/src/tools.rs b/crates/agent2/src/tools.rs
index bcca7eecd1..d1f2b3b1c7 100644
--- a/crates/agent2/src/tools.rs
+++ b/crates/agent2/src/tools.rs
@@ -16,29 +16,6 @@ mod terminal_tool;
mod thinking_tool;
mod web_search_tool;
-/// A list of all built in tool names, for use in deduplicating MCP tool names
-pub fn default_tool_names() -> impl Iterator
- {
- [
- CopyPathTool::name(),
- CreateDirectoryTool::name(),
- DeletePathTool::name(),
- DiagnosticsTool::name(),
- EditFileTool::name(),
- FetchTool::name(),
- FindPathTool::name(),
- GrepTool::name(),
- ListDirectoryTool::name(),
- MovePathTool::name(),
- NowTool::name(),
- OpenTool::name(),
- ReadFileTool::name(),
- TerminalTool::name(),
- ThinkingTool::name(),
- WebSearchTool::name(),
- ]
- .into_iter()
-}
-
pub use context_server_registry::*;
pub use copy_path_tool::*;
pub use create_directory_tool::*;
@@ -56,5 +33,3 @@ pub use read_file_tool::*;
pub use terminal_tool::*;
pub use thinking_tool::*;
pub use web_search_tool::*;
-
-use crate::AgentTool;
diff --git a/crates/agent2/src/tools/copy_path_tool.rs b/crates/agent2/src/tools/copy_path_tool.rs
index 819a6ff209..4b40a9842f 100644
--- a/crates/agent2/src/tools/copy_path_tool.rs
+++ b/crates/agent2/src/tools/copy_path_tool.rs
@@ -1,7 +1,7 @@
use crate::{AgentTool, ToolCallEventStream};
use agent_client_protocol::ToolKind;
use anyhow::{Context as _, Result, anyhow};
-use gpui::{App, AppContext, Entity, Task};
+use gpui::{App, AppContext, Entity, SharedString, Task};
use project::Project;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
@@ -50,11 +50,11 @@ impl AgentTool for CopyPathTool {
type Input = CopyPathToolInput;
type Output = String;
- fn name() -> &'static str {
- "copy_path"
+ fn name(&self) -> SharedString {
+ "copy_path".into()
}
- fn kind() -> ToolKind {
+ fn kind(&self) -> ToolKind {
ToolKind::Move
}
diff --git a/crates/agent2/src/tools/create_directory_tool.rs b/crates/agent2/src/tools/create_directory_tool.rs
index 652363d5fa..7720eb3595 100644
--- a/crates/agent2/src/tools/create_directory_tool.rs
+++ b/crates/agent2/src/tools/create_directory_tool.rs
@@ -41,11 +41,11 @@ impl AgentTool for CreateDirectoryTool {
type Input = CreateDirectoryToolInput;
type Output = String;
- fn name() -> &'static str {
- "create_directory"
+ fn name(&self) -> SharedString {
+ "create_directory".into()
}
- fn kind() -> ToolKind {
+ fn kind(&self) -> ToolKind {
ToolKind::Read
}
diff --git a/crates/agent2/src/tools/delete_path_tool.rs b/crates/agent2/src/tools/delete_path_tool.rs
index 0f9641127f..c281f1b5b6 100644
--- a/crates/agent2/src/tools/delete_path_tool.rs
+++ b/crates/agent2/src/tools/delete_path_tool.rs
@@ -44,11 +44,11 @@ impl AgentTool for DeletePathTool {
type Input = DeletePathToolInput;
type Output = String;
- fn name() -> &'static str {
- "delete_path"
+ fn name(&self) -> SharedString {
+ "delete_path".into()
}
- fn kind() -> ToolKind {
+ fn kind(&self) -> ToolKind {
ToolKind::Delete
}
diff --git a/crates/agent2/src/tools/diagnostics_tool.rs b/crates/agent2/src/tools/diagnostics_tool.rs
index 558bb918ce..6ba8b7b377 100644
--- a/crates/agent2/src/tools/diagnostics_tool.rs
+++ b/crates/agent2/src/tools/diagnostics_tool.rs
@@ -63,11 +63,11 @@ impl AgentTool for DiagnosticsTool {
type Input = DiagnosticsToolInput;
type Output = String;
- fn name() -> &'static str {
- "diagnostics"
+ fn name(&self) -> SharedString {
+ "diagnostics".into()
}
- fn kind() -> acp::ToolKind {
+ fn kind(&self) -> acp::ToolKind {
acp::ToolKind::Read
}
diff --git a/crates/agent2/src/tools/edit_file_tool.rs b/crates/agent2/src/tools/edit_file_tool.rs
index f86bfd25f7..f89cace9a8 100644
--- a/crates/agent2/src/tools/edit_file_tool.rs
+++ b/crates/agent2/src/tools/edit_file_tool.rs
@@ -186,11 +186,11 @@ impl AgentTool for EditFileTool {
type Input = EditFileToolInput;
type Output = EditFileToolOutput;
- fn name() -> &'static str {
- "edit_file"
+ fn name(&self) -> SharedString {
+ "edit_file".into()
}
- fn kind() -> acp::ToolKind {
+ fn kind(&self) -> acp::ToolKind {
acp::ToolKind::Edit
}
@@ -273,13 +273,6 @@ impl AgentTool for EditFileTool {
let diff = cx.new(|cx| Diff::new(buffer.clone(), cx))?;
event_stream.update_diff(diff.clone());
- let _finalize_diff = util::defer({
- let diff = diff.downgrade();
- let mut cx = cx.clone();
- move || {
- diff.update(&mut cx, |diff, cx| diff.finalize(cx)).ok();
- }
- });
let old_snapshot = buffer.read_with(cx, |buffer, _cx| buffer.snapshot())?;
let old_text = cx
@@ -396,6 +389,8 @@ impl AgentTool for EditFileTool {
})
.await;
+ diff.update(cx, |diff, cx| diff.finalize(cx)).ok();
+
let input_path = input.path.display();
if unified_diff.is_empty() {
anyhow::ensure!(
@@ -522,6 +517,7 @@ fn resolve_path(
mod tests {
use super::*;
use crate::{ContextServerRegistry, Templates};
+ use action_log::ActionLog;
use client::TelemetrySettings;
use fs::Fs;
use gpui::{TestAppContext, UpdateGlobal};
@@ -539,6 +535,7 @@ mod tests {
fs.insert_tree("/root", json!({})).await;
let project = Project::test(fs.clone(), [path!("/root").as_ref()], cx).await;
let language_registry = project.read_with(cx, |project, _cx| project.languages().clone());
+ let action_log = cx.new(|_| ActionLog::new(project.clone()));
let context_server_registry =
cx.new(|cx| ContextServerRegistry::new(project.read(cx).context_server_store(), cx));
let model = Arc::new(FakeLanguageModel::default());
@@ -547,6 +544,7 @@ mod tests {
project,
cx.new(|_cx| ProjectContext::default()),
context_server_registry,
+ action_log,
Templates::new(),
Some(model),
cx,
@@ -737,6 +735,7 @@ mod tests {
}
});
+ let action_log = cx.new(|_| ActionLog::new(project.clone()));
let context_server_registry =
cx.new(|cx| ContextServerRegistry::new(project.read(cx).context_server_store(), cx));
let model = Arc::new(FakeLanguageModel::default());
@@ -745,6 +744,7 @@ mod tests {
project,
cx.new(|_cx| ProjectContext::default()),
context_server_registry,
+ action_log.clone(),
Templates::new(),
Some(model.clone()),
cx,
@@ -801,9 +801,7 @@ mod tests {
"Code should be formatted when format_on_save is enabled"
);
- let stale_buffer_count = thread
- .read_with(cx, |thread, _cx| thread.action_log.clone())
- .read_with(cx, |log, cx| log.stale_buffers(cx).count());
+ let stale_buffer_count = action_log.read_with(cx, |log, cx| log.stale_buffers(cx).count());
assert_eq!(
stale_buffer_count, 0,
@@ -881,12 +879,14 @@ mod tests {
let context_server_registry =
cx.new(|cx| ContextServerRegistry::new(project.read(cx).context_server_store(), cx));
let language_registry = project.read_with(cx, |project, _cx| project.languages().clone());
+ let action_log = cx.new(|_| ActionLog::new(project.clone()));
let model = Arc::new(FakeLanguageModel::default());
let thread = cx.new(|cx| {
Thread::new(
project,
cx.new(|_cx| ProjectContext::default()),
context_server_registry,
+ action_log.clone(),
Templates::new(),
Some(model.clone()),
cx,
@@ -1008,12 +1008,14 @@ mod tests {
let context_server_registry =
cx.new(|cx| ContextServerRegistry::new(project.read(cx).context_server_store(), cx));
let language_registry = project.read_with(cx, |project, _cx| project.languages().clone());
+ let action_log = cx.new(|_| ActionLog::new(project.clone()));
let model = Arc::new(FakeLanguageModel::default());
let thread = cx.new(|cx| {
Thread::new(
project,
cx.new(|_cx| ProjectContext::default()),
context_server_registry,
+ action_log.clone(),
Templates::new(),
Some(model.clone()),
cx,
@@ -1144,12 +1146,14 @@ mod tests {
let language_registry = project.read_with(cx, |project, _cx| project.languages().clone());
let context_server_registry =
cx.new(|cx| ContextServerRegistry::new(project.read(cx).context_server_store(), cx));
+ let action_log = cx.new(|_| ActionLog::new(project.clone()));
let model = Arc::new(FakeLanguageModel::default());
let thread = cx.new(|cx| {
Thread::new(
project,
cx.new(|_cx| ProjectContext::default()),
context_server_registry,
+ action_log.clone(),
Templates::new(),
Some(model.clone()),
cx,
@@ -1250,6 +1254,7 @@ mod tests {
)
.await;
let language_registry = project.read_with(cx, |project, _cx| project.languages().clone());
+ let action_log = cx.new(|_| ActionLog::new(project.clone()));
let context_server_registry =
cx.new(|cx| ContextServerRegistry::new(project.read(cx).context_server_store(), cx));
let model = Arc::new(FakeLanguageModel::default());
@@ -1258,6 +1263,7 @@ mod tests {
project.clone(),
cx.new(|_cx| ProjectContext::default()),
context_server_registry.clone(),
+ action_log.clone(),
Templates::new(),
Some(model.clone()),
cx,
@@ -1330,6 +1336,7 @@ mod tests {
.await;
let project = Project::test(fs.clone(), [path!("/project").as_ref()], cx).await;
let language_registry = project.read_with(cx, |project, _cx| project.languages().clone());
+ let action_log = cx.new(|_| ActionLog::new(project.clone()));
let context_server_registry =
cx.new(|cx| ContextServerRegistry::new(project.read(cx).context_server_store(), cx));
let model = Arc::new(FakeLanguageModel::default());
@@ -1338,6 +1345,7 @@ mod tests {
project.clone(),
cx.new(|_cx| ProjectContext::default()),
context_server_registry.clone(),
+ action_log.clone(),
Templates::new(),
Some(model.clone()),
cx,
@@ -1413,6 +1421,7 @@ mod tests {
.await;
let project = Project::test(fs.clone(), [path!("/project").as_ref()], cx).await;
let language_registry = project.read_with(cx, |project, _cx| project.languages().clone());
+ let action_log = cx.new(|_| ActionLog::new(project.clone()));
let context_server_registry =
cx.new(|cx| ContextServerRegistry::new(project.read(cx).context_server_store(), cx));
let model = Arc::new(FakeLanguageModel::default());
@@ -1421,6 +1430,7 @@ mod tests {
project.clone(),
cx.new(|_cx| ProjectContext::default()),
context_server_registry.clone(),
+ action_log.clone(),
Templates::new(),
Some(model.clone()),
cx,
@@ -1493,6 +1503,7 @@ mod tests {
let fs = project::FakeFs::new(cx.executor());
let project = Project::test(fs.clone(), [path!("/project").as_ref()], cx).await;
let language_registry = project.read_with(cx, |project, _cx| project.languages().clone());
+ let action_log = cx.new(|_| ActionLog::new(project.clone()));
let context_server_registry =
cx.new(|cx| ContextServerRegistry::new(project.read(cx).context_server_store(), cx));
let model = Arc::new(FakeLanguageModel::default());
@@ -1501,6 +1512,7 @@ mod tests {
project.clone(),
cx.new(|_cx| ProjectContext::default()),
context_server_registry,
+ action_log.clone(),
Templates::new(),
Some(model.clone()),
cx,
@@ -1550,100 +1562,6 @@ mod tests {
);
}
- #[gpui::test]
- async fn test_diff_finalization(cx: &mut TestAppContext) {
- init_test(cx);
- let fs = project::FakeFs::new(cx.executor());
- fs.insert_tree("/", json!({"main.rs": ""})).await;
-
- let project = Project::test(fs.clone(), [path!("/").as_ref()], cx).await;
- let languages = project.read_with(cx, |project, _cx| project.languages().clone());
- let context_server_registry =
- cx.new(|cx| ContextServerRegistry::new(project.read(cx).context_server_store(), cx));
- let model = Arc::new(FakeLanguageModel::default());
- let thread = cx.new(|cx| {
- Thread::new(
- project.clone(),
- cx.new(|_cx| ProjectContext::default()),
- context_server_registry.clone(),
- Templates::new(),
- Some(model.clone()),
- cx,
- )
- });
-
- // Ensure the diff is finalized after the edit completes.
- {
- let tool = Arc::new(EditFileTool::new(thread.downgrade(), languages.clone()));
- let (stream_tx, mut stream_rx) = ToolCallEventStream::test();
- let edit = cx.update(|cx| {
- tool.run(
- EditFileToolInput {
- display_description: "Edit file".into(),
- path: path!("/main.rs").into(),
- mode: EditFileMode::Edit,
- },
- stream_tx,
- cx,
- )
- });
- stream_rx.expect_update_fields().await;
- let diff = stream_rx.expect_diff().await;
- diff.read_with(cx, |diff, _| assert!(matches!(diff, Diff::Pending(_))));
- cx.run_until_parked();
- model.end_last_completion_stream();
- edit.await.unwrap();
- diff.read_with(cx, |diff, _| assert!(matches!(diff, Diff::Finalized(_))));
- }
-
- // Ensure the diff is finalized if an error occurs while editing.
- {
- model.forbid_requests();
- let tool = Arc::new(EditFileTool::new(thread.downgrade(), languages.clone()));
- let (stream_tx, mut stream_rx) = ToolCallEventStream::test();
- let edit = cx.update(|cx| {
- tool.run(
- EditFileToolInput {
- display_description: "Edit file".into(),
- path: path!("/main.rs").into(),
- mode: EditFileMode::Edit,
- },
- stream_tx,
- cx,
- )
- });
- stream_rx.expect_update_fields().await;
- let diff = stream_rx.expect_diff().await;
- diff.read_with(cx, |diff, _| assert!(matches!(diff, Diff::Pending(_))));
- edit.await.unwrap_err();
- diff.read_with(cx, |diff, _| assert!(matches!(diff, Diff::Finalized(_))));
- model.allow_requests();
- }
-
- // Ensure the diff is finalized if the tool call gets dropped.
- {
- let tool = Arc::new(EditFileTool::new(thread.downgrade(), languages.clone()));
- let (stream_tx, mut stream_rx) = ToolCallEventStream::test();
- let edit = cx.update(|cx| {
- tool.run(
- EditFileToolInput {
- display_description: "Edit file".into(),
- path: path!("/main.rs").into(),
- mode: EditFileMode::Edit,
- },
- stream_tx,
- cx,
- )
- });
- stream_rx.expect_update_fields().await;
- let diff = stream_rx.expect_diff().await;
- diff.read_with(cx, |diff, _| assert!(matches!(diff, Diff::Pending(_))));
- drop(edit);
- cx.run_until_parked();
- diff.read_with(cx, |diff, _| assert!(matches!(diff, Diff::Finalized(_))));
- }
- }
-
fn init_test(cx: &mut TestAppContext) {
cx.update(|cx| {
let settings_store = SettingsStore::test(cx);
diff --git a/crates/agent2/src/tools/fetch_tool.rs b/crates/agent2/src/tools/fetch_tool.rs
index dd97271a79..ae26c5fe19 100644
--- a/crates/agent2/src/tools/fetch_tool.rs
+++ b/crates/agent2/src/tools/fetch_tool.rs
@@ -118,11 +118,11 @@ impl AgentTool for FetchTool {
type Input = FetchToolInput;
type Output = String;
- fn name() -> &'static str {
- "fetch"
+ fn name(&self) -> SharedString {
+ "fetch".into()
}
- fn kind() -> acp::ToolKind {
+ fn kind(&self) -> acp::ToolKind {
acp::ToolKind::Fetch
}
@@ -136,17 +136,12 @@ impl AgentTool for FetchTool {
fn run(
self: Arc,
input: Self::Input,
- event_stream: ToolCallEventStream,
+ _event_stream: ToolCallEventStream,
cx: &mut App,
) -> Task> {
- let authorize = event_stream.authorize(input.url.clone(), cx);
-
let text = cx.background_spawn({
let http_client = self.http_client.clone();
- async move {
- authorize.await?;
- Self::build_message(http_client, &input.url).await
- }
+ async move { Self::build_message(http_client, &input.url).await }
});
cx.foreground_executor().spawn(async move {
diff --git a/crates/agent2/src/tools/find_path_tool.rs b/crates/agent2/src/tools/find_path_tool.rs
index 384bd56e77..9e11ca6a37 100644
--- a/crates/agent2/src/tools/find_path_tool.rs
+++ b/crates/agent2/src/tools/find_path_tool.rs
@@ -85,11 +85,11 @@ impl AgentTool for FindPathTool {
type Input = FindPathToolInput;
type Output = FindPathToolOutput;
- fn name() -> &'static str {
- "find_path"
+ fn name(&self) -> SharedString {
+ "find_path".into()
}
- fn kind() -> acp::ToolKind {
+ fn kind(&self) -> acp::ToolKind {
acp::ToolKind::Search
}
@@ -165,17 +165,16 @@ fn search_paths(glob: &str, project: Entity, cx: &mut App) -> Task &'static str {
- "grep"
+ fn name(&self) -> SharedString {
+ "grep".into()
}
- fn kind() -> acp::ToolKind {
+ fn kind(&self) -> acp::ToolKind {
acp::ToolKind::Search
}
diff --git a/crates/agent2/src/tools/list_directory_tool.rs b/crates/agent2/src/tools/list_directory_tool.rs
index e6fa8d7431..31575a92e4 100644
--- a/crates/agent2/src/tools/list_directory_tool.rs
+++ b/crates/agent2/src/tools/list_directory_tool.rs
@@ -51,11 +51,11 @@ impl AgentTool for ListDirectoryTool {
type Input = ListDirectoryToolInput;
type Output = String;
- fn name() -> &'static str {
- "list_directory"
+ fn name(&self) -> SharedString {
+ "list_directory".into()
}
- fn kind() -> ToolKind {
+ fn kind(&self) -> ToolKind {
ToolKind::Read
}
diff --git a/crates/agent2/src/tools/move_path_tool.rs b/crates/agent2/src/tools/move_path_tool.rs
index d9fb60651b..2a173a4404 100644
--- a/crates/agent2/src/tools/move_path_tool.rs
+++ b/crates/agent2/src/tools/move_path_tool.rs
@@ -52,11 +52,11 @@ impl AgentTool for MovePathTool {
type Input = MovePathToolInput;
type Output = String;
- fn name() -> &'static str {
- "move_path"
+ fn name(&self) -> SharedString {
+ "move_path".into()
}
- fn kind() -> ToolKind {
+ fn kind(&self) -> ToolKind {
ToolKind::Move
}
diff --git a/crates/agent2/src/tools/now_tool.rs b/crates/agent2/src/tools/now_tool.rs
index 9467e7db68..a72ede26fe 100644
--- a/crates/agent2/src/tools/now_tool.rs
+++ b/crates/agent2/src/tools/now_tool.rs
@@ -32,11 +32,11 @@ impl AgentTool for NowTool {
type Input = NowToolInput;
type Output = String;
- fn name() -> &'static str {
- "now"
+ fn name(&self) -> SharedString {
+ "now".into()
}
- fn kind() -> acp::ToolKind {
+ fn kind(&self) -> acp::ToolKind {
acp::ToolKind::Other
}
diff --git a/crates/agent2/src/tools/open_tool.rs b/crates/agent2/src/tools/open_tool.rs
index df7b04c787..c20369c2d8 100644
--- a/crates/agent2/src/tools/open_tool.rs
+++ b/crates/agent2/src/tools/open_tool.rs
@@ -37,11 +37,11 @@ impl AgentTool for OpenTool {
type Input = OpenToolInput;
type Output = String;
- fn name() -> &'static str {
- "open"
+ fn name(&self) -> SharedString {
+ "open".into()
}
- fn kind() -> ToolKind {
+ fn kind(&self) -> ToolKind {
ToolKind::Execute
}
diff --git a/crates/agent2/src/tools/read_file_tool.rs b/crates/agent2/src/tools/read_file_tool.rs
index e771c26eca..11a57506fb 100644
--- a/crates/agent2/src/tools/read_file_tool.rs
+++ b/crates/agent2/src/tools/read_file_tool.rs
@@ -10,8 +10,7 @@ use project::{AgentLocation, ImageItem, Project, WorktreeSettings, image_store};
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use settings::Settings;
-use std::{path::Path, sync::Arc};
-use util::markdown::MarkdownCodeBlock;
+use std::sync::Arc;
use crate::{AgentTool, ToolCallEventStream};
@@ -60,21 +59,36 @@ impl AgentTool for ReadFileTool {
type Input = ReadFileToolInput;
type Output = LanguageModelToolResultContent;
- fn name() -> &'static str {
- "read_file"
+ fn name(&self) -> SharedString {
+ "read_file".into()
}
- fn kind() -> acp::ToolKind {
+ fn kind(&self) -> acp::ToolKind {
acp::ToolKind::Read
}
fn initial_title(&self, input: Result) -> SharedString {
- input
- .ok()
- .as_ref()
- .and_then(|input| Path::new(&input.path).file_name())
- .map(|file_name| file_name.to_string_lossy().to_string().into())
- .unwrap_or_default()
+ if let Ok(input) = input {
+ let path = &input.path;
+ match (input.start_line, input.end_line) {
+ (Some(start), Some(end)) => {
+ format!(
+ "[Read file `{}` (lines {}-{})](@selection:{}:({}-{}))",
+ path, start, end, path, start, end
+ )
+ }
+ (Some(start), None) => {
+ format!(
+ "[Read file `{}` (from line {})](@selection:{}:({}-{}))",
+ path, start, path, start, start
+ )
+ }
+ _ => format!("[Read file `{}`](@file:{})", path, path),
+ }
+ .into()
+ } else {
+ "Read file".into()
+ }
}
fn run(
@@ -244,19 +258,6 @@ impl AgentTool for ReadFileTool {
}]),
..Default::default()
});
- if let Ok(LanguageModelToolResultContent::Text(text)) = &result {
- let markdown = MarkdownCodeBlock {
- tag: &input.path,
- text,
- }
- .to_string();
- event_stream.update_fields(ToolCallUpdateFields {
- content: Some(vec![acp::ToolCallContent::Content {
- content: markdown.into(),
- }]),
- ..Default::default()
- })
- }
}
})?;
diff --git a/crates/agent2/src/tools/terminal_tool.rs b/crates/agent2/src/tools/terminal_tool.rs
index f41b909d0b..3d4faf2e03 100644
--- a/crates/agent2/src/tools/terminal_tool.rs
+++ b/crates/agent2/src/tools/terminal_tool.rs
@@ -63,11 +63,11 @@ impl AgentTool for TerminalTool {
type Input = TerminalToolInput;
type Output = String;
- fn name() -> &'static str {
- "terminal"
+ fn name(&self) -> SharedString {
+ "terminal".into()
}
- fn kind() -> acp::ToolKind {
+ fn kind(&self) -> acp::ToolKind {
acp::ToolKind::Execute
}
diff --git a/crates/agent2/src/tools/thinking_tool.rs b/crates/agent2/src/tools/thinking_tool.rs
index 61fb9eb0d6..c5e9451162 100644
--- a/crates/agent2/src/tools/thinking_tool.rs
+++ b/crates/agent2/src/tools/thinking_tool.rs
@@ -21,11 +21,11 @@ impl AgentTool for ThinkingTool {
type Input = ThinkingToolInput;
type Output = String;
- fn name() -> &'static str {
- "thinking"
+ fn name(&self) -> SharedString {
+ "thinking".into()
}
- fn kind() -> acp::ToolKind {
+ fn kind(&self) -> acp::ToolKind {
acp::ToolKind::Think
}
diff --git a/crates/agent2/src/tools/web_search_tool.rs b/crates/agent2/src/tools/web_search_tool.rs
index d7a34bec29..ffcd4ad3be 100644
--- a/crates/agent2/src/tools/web_search_tool.rs
+++ b/crates/agent2/src/tools/web_search_tool.rs
@@ -40,11 +40,11 @@ impl AgentTool for WebSearchTool {
type Input = WebSearchToolInput;
type Output = WebSearchToolOutput;
- fn name() -> &'static str {
- "web_search"
+ fn name(&self) -> SharedString {
+ "web_search".into()
}
- fn kind() -> acp::ToolKind {
+ fn kind(&self) -> acp::ToolKind {
acp::ToolKind::Fetch
}
diff --git a/crates/agent_servers/Cargo.toml b/crates/agent_servers/Cargo.toml
index 9f90f3a78a..60dd796463 100644
--- a/crates/agent_servers/Cargo.toml
+++ b/crates/agent_servers/Cargo.toml
@@ -17,11 +17,11 @@ path = "src/agent_servers.rs"
doctest = false
[dependencies]
-acp_tools.workspace = true
acp_thread.workspace = true
action_log.workspace = true
agent-client-protocol.workspace = true
agent_settings.workspace = true
+agentic-coding-protocol.workspace = true
anyhow.workspace = true
client = { workspace = true, optional = true }
collections.workspace = true
diff --git a/crates/agent_servers/src/acp.rs b/crates/agent_servers/src/acp.rs
index b4e897374a..1cfb1fcabf 100644
--- a/crates/agent_servers/src/acp.rs
+++ b/crates/agent_servers/src/acp.rs
@@ -1,414 +1,34 @@
+use std::{path::Path, rc::Rc};
+
use crate::AgentServerCommand;
use acp_thread::AgentConnection;
-use acp_tools::AcpConnectionRegistry;
-use action_log::ActionLog;
-use agent_client_protocol::{self as acp, Agent as _, ErrorCode};
-use anyhow::anyhow;
-use collections::HashMap;
-use futures::AsyncBufReadExt as _;
-use futures::channel::oneshot;
-use futures::io::BufReader;
-use project::Project;
-use serde::Deserialize;
-use std::{any::Any, cell::RefCell};
-use std::{path::Path, rc::Rc};
+use anyhow::Result;
+use gpui::AsyncApp;
use thiserror::Error;
-use anyhow::{Context as _, Result};
-use gpui::{App, AppContext as _, AsyncApp, Entity, SharedString, Task, WeakEntity};
-
-use acp_thread::{AcpThread, AuthRequired, LoadError};
+mod v0;
+mod v1;
#[derive(Debug, Error)]
#[error("Unsupported version")]
pub struct UnsupportedVersion;
-pub struct AcpConnection {
- server_name: SharedString,
- connection: Rc,
- sessions: Rc>>,
- auth_methods: Vec,
- prompt_capabilities: acp::PromptCapabilities,
- _io_task: Task>,
-}
-
-pub struct AcpSession {
- thread: WeakEntity,
- suppress_abort_err: bool,
-}
-
pub async fn connect(
- server_name: SharedString,
+ server_name: &'static str,
command: AgentServerCommand,
root_dir: &Path,
cx: &mut AsyncApp,
) -> Result> {
- let conn = AcpConnection::stdio(server_name, command.clone(), root_dir, cx).await?;
- Ok(Rc::new(conn) as _)
-}
+ let conn = v1::AcpConnection::stdio(server_name, command.clone(), root_dir, cx).await;
-const MINIMUM_SUPPORTED_VERSION: acp::ProtocolVersion = acp::V1;
-
-impl AcpConnection {
- pub async fn stdio(
- server_name: SharedString,
- command: AgentServerCommand,
- root_dir: &Path,
- cx: &mut AsyncApp,
- ) -> Result {
- let mut child = util::command::new_smol_command(&command.path)
- .args(command.args.iter().map(|arg| arg.as_str()))
- .envs(command.env.iter().flatten())
- .current_dir(root_dir)
- .stdin(std::process::Stdio::piped())
- .stdout(std::process::Stdio::piped())
- .stderr(std::process::Stdio::piped())
- .kill_on_drop(true)
- .spawn()?;
-
- 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()));
-
- let client = ClientDelegate {
- sessions: sessions.clone(),
- cx: cx.clone(),
- };
- let (connection, io_task) = acp::ClientSideConnection::new(client, stdin, stdout, {
- let foreground_executor = cx.foreground_executor().clone();
- move |fut| {
- foreground_executor.spawn(fut).detach();
- }
- });
-
- 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| {
- let status = child.status().await?;
-
- for session in sessions.borrow().values() {
- session
- .thread
- .update(cx, |thread, cx| {
- thread.emit_load_error(LoadError::Exited { status }, cx)
- })
- .ok();
- }
-
- anyhow::Ok(())
- }
- })
- .detach();
-
- let connection = Rc::new(connection);
-
- cx.update(|cx| {
- AcpConnectionRegistry::default_global(cx).update(cx, |registry, cx| {
- registry.set_active_connection(server_name.clone(), &connection, cx)
- });
- })?;
-
- let response = connection
- .initialize(acp::InitializeRequest {
- protocol_version: acp::VERSION,
- client_capabilities: acp::ClientCapabilities {
- fs: acp::FileSystemCapability {
- read_text_file: true,
- write_text_file: true,
- },
- },
- })
- .await?;
-
- if response.protocol_version < MINIMUM_SUPPORTED_VERSION {
- return Err(UnsupportedVersion.into());
+ match conn {
+ Ok(conn) => Ok(Rc::new(conn) as _),
+ Err(err) if err.is::() => {
+ // Consider re-using initialize response and subprocess when adding another version here
+ let conn: Rc =
+ Rc::new(v0::AcpConnection::stdio(server_name, command, root_dir, cx).await?);
+ Ok(conn)
}
-
- Ok(Self {
- auth_methods: response.auth_methods,
- connection,
- server_name,
- sessions,
- prompt_capabilities: response.agent_capabilities.prompt_capabilities,
- _io_task: io_task,
- })
- }
-}
-
-impl AgentConnection for AcpConnection {
- fn new_thread(
- self: Rc,
- project: Entity,
- cwd: &Path,
- cx: &mut App,
- ) -> Task>> {
- let conn = self.connection.clone();
- let sessions = self.sessions.clone();
- let cwd = cwd.to_path_buf();
- let context_server_store = project.read(cx).context_server_store().read(cx);
- let mcp_servers = context_server_store
- .configured_server_ids()
- .iter()
- .filter_map(|id| {
- let configuration = context_server_store.configuration_for_server(id)?;
- let command = configuration.command();
- Some(acp::McpServer {
- name: id.0.to_string(),
- command: command.path.clone(),
- args: command.args.clone(),
- env: if let Some(env) = command.env.as_ref() {
- env.iter()
- .map(|(name, value)| acp::EnvVariable {
- name: name.clone(),
- value: value.clone(),
- })
- .collect()
- } else {
- vec![]
- },
- })
- })
- .collect();
-
- cx.spawn(async move |cx| {
- let response = conn
- .new_session(acp::NewSessionRequest { mcp_servers, cwd })
- .await
- .map_err(|err| {
- if err.code == acp::ErrorCode::AUTH_REQUIRED.code {
- let mut error = AuthRequired::new();
-
- if err.message != acp::ErrorCode::AUTH_REQUIRED.message {
- error = error.with_description(err.message);
- }
-
- anyhow!(error)
- } else {
- anyhow!(err)
- }
- })?;
-
- let session_id = response.session_id;
- let action_log = cx.new(|_| ActionLog::new(project.clone()))?;
- let thread = cx.new(|cx| {
- AcpThread::new(
- self.server_name.clone(),
- self.clone(),
- project,
- action_log,
- session_id.clone(),
- // ACP doesn't currently support per-session prompt capabilities or changing capabilities dynamically.
- watch::Receiver::constant(self.prompt_capabilities),
- cx,
- )
- })?;
-
- let session = AcpSession {
- thread: thread.downgrade(),
- suppress_abort_err: false,
- };
- sessions.borrow_mut().insert(session_id, session);
-
- Ok(thread)
- })
- }
-
- fn auth_methods(&self) -> &[acp::AuthMethod] {
- &self.auth_methods
- }
-
- fn authenticate(&self, method_id: acp::AuthMethodId, cx: &mut App) -> Task> {
- let conn = self.connection.clone();
- cx.foreground_executor().spawn(async move {
- let result = conn
- .authenticate(acp::AuthenticateRequest {
- method_id: method_id.clone(),
- })
- .await?;
-
- Ok(result)
- })
- }
-
- fn prompt(
- &self,
- _id: Option,
- params: acp::PromptRequest,
- cx: &mut App,
- ) -> Task> {
- let conn = self.connection.clone();
- let sessions = self.sessions.clone();
- let session_id = params.session_id.clone();
- cx.foreground_executor().spawn(async move {
- let result = conn.prompt(params).await;
-
- let mut suppress_abort_err = false;
-
- if let Some(session) = sessions.borrow_mut().get_mut(&session_id) {
- suppress_abort_err = session.suppress_abort_err;
- session.suppress_abort_err = false;
- }
-
- match result {
- Ok(response) => Ok(response),
- Err(err) => {
- if err.code != ErrorCode::INTERNAL_ERROR.code {
- anyhow::bail!(err)
- }
-
- let Some(data) = &err.data else {
- anyhow::bail!(err)
- };
-
- // Temporary workaround until the following PR is generally available:
- // https://github.com/google-gemini/gemini-cli/pull/6656
-
- #[derive(Deserialize)]
- #[serde(deny_unknown_fields)]
- struct ErrorDetails {
- details: Box,
- }
-
- match serde_json::from_value(data.clone()) {
- Ok(ErrorDetails { details }) => {
- if suppress_abort_err
- && (details.contains("This operation was aborted")
- || details.contains("The user aborted a request"))
- {
- Ok(acp::PromptResponse {
- stop_reason: acp::StopReason::Cancelled,
- })
- } else {
- Err(anyhow!(details))
- }
- }
- Err(_) => Err(anyhow!(err)),
- }
- }
- }
- })
- }
-
- fn cancel(&self, session_id: &acp::SessionId, cx: &mut App) {
- if let Some(session) = self.sessions.borrow_mut().get_mut(session_id) {
- session.suppress_abort_err = true;
- }
- let conn = self.connection.clone();
- let params = acp::CancelNotification {
- session_id: session_id.clone(),
- };
- cx.foreground_executor()
- .spawn(async move { conn.cancel(params).await })
- .detach();
- }
-
- fn into_any(self: Rc) -> Rc {
- self
- }
-}
-
-struct ClientDelegate {
- sessions: Rc>>,
- cx: AsyncApp,
-}
-
-impl acp::Client for ClientDelegate {
- async fn request_permission(
- &self,
- arguments: acp::RequestPermissionRequest,
- ) -> Result {
- let cx = &mut self.cx.clone();
- let rx = self
- .sessions
- .borrow()
- .get(&arguments.session_id)
- .context("Failed to get session")?
- .thread
- .update(cx, |thread, cx| {
- thread.request_tool_call_authorization(arguments.tool_call, arguments.options, cx)
- })?;
-
- let result = rx?.await;
-
- let outcome = match result {
- Ok(option) => acp::RequestPermissionOutcome::Selected { option_id: option },
- Err(oneshot::Canceled) => acp::RequestPermissionOutcome::Cancelled,
- };
-
- Ok(acp::RequestPermissionResponse { outcome })
- }
-
- async fn write_text_file(
- &self,
- arguments: acp::WriteTextFileRequest,
- ) -> Result<(), acp::Error> {
- let cx = &mut self.cx.clone();
- let task = self
- .sessions
- .borrow()
- .get(&arguments.session_id)
- .context("Failed to get session")?
- .thread
- .update(cx, |thread, cx| {
- thread.write_text_file(arguments.path, arguments.content, cx)
- })?;
-
- task.await?;
-
- Ok(())
- }
-
- async fn read_text_file(
- &self,
- arguments: acp::ReadTextFileRequest,
- ) -> Result {
- let cx = &mut self.cx.clone();
- let task = self
- .sessions
- .borrow()
- .get(&arguments.session_id)
- .context("Failed to get session")?
- .thread
- .update(cx, |thread, cx| {
- thread.read_text_file(arguments.path, arguments.line, arguments.limit, false, cx)
- })?;
-
- let content = task.await?;
-
- Ok(acp::ReadTextFileResponse { content })
- }
-
- async fn session_notification(
- &self,
- notification: acp::SessionNotification,
- ) -> Result<(), acp::Error> {
- let cx = &mut self.cx.clone();
- let sessions = self.sessions.borrow();
- let session = sessions
- .get(¬ification.session_id)
- .context("Failed to get session")?;
-
- session.thread.update(cx, |thread, cx| {
- thread.handle_session_update(notification.update, cx)
- })??;
-
- Ok(())
+ Err(err) => Err(err),
}
}
diff --git a/crates/agent_servers/src/acp/v0.rs b/crates/agent_servers/src/acp/v0.rs
new file mode 100644
index 0000000000..be96048929
--- /dev/null
+++ b/crates/agent_servers/src/acp/v0.rs
@@ -0,0 +1,524 @@
+// Translates old acp agents into the new schema
+use action_log::ActionLog;
+use agent_client_protocol as acp;
+use agentic_coding_protocol::{self as acp_old, AgentRequest as _};
+use anyhow::{Context as _, Result, anyhow};
+use futures::channel::oneshot;
+use gpui::{AppContext as _, AsyncApp, Entity, Task, WeakEntity};
+use project::Project;
+use std::{any::Any, cell::RefCell, path::Path, rc::Rc};
+use ui::App;
+use util::ResultExt as _;
+
+use crate::AgentServerCommand;
+use acp_thread::{AcpThread, AgentConnection, AuthRequired};
+
+#[derive(Clone)]
+struct OldAcpClientDelegate {
+ thread: Rc>>,
+ cx: AsyncApp,
+ next_tool_call_id: Rc>,
+ // sent_buffer_versions: HashMap, HashMap>,
+}
+
+impl OldAcpClientDelegate {
+ fn new(thread: Rc>>, cx: AsyncApp) -> Self {
+ Self {
+ thread,
+ cx,
+ next_tool_call_id: Rc::new(RefCell::new(0)),
+ }
+ }
+}
+
+impl acp_old::Client for OldAcpClientDelegate {
+ async fn stream_assistant_message_chunk(
+ &self,
+ params: acp_old::StreamAssistantMessageChunkParams,
+ ) -> Result<(), acp_old::Error> {
+ let cx = &mut self.cx.clone();
+
+ cx.update(|cx| {
+ self.thread
+ .borrow()
+ .update(cx, |thread, cx| match params.chunk {
+ acp_old::AssistantMessageChunk::Text { text } => {
+ thread.push_assistant_content_block(text.into(), false, cx)
+ }
+ acp_old::AssistantMessageChunk::Thought { thought } => {
+ thread.push_assistant_content_block(thought.into(), true, cx)
+ }
+ })
+ .log_err();
+ })?;
+
+ Ok(())
+ }
+
+ async fn request_tool_call_confirmation(
+ &self,
+ request: acp_old::RequestToolCallConfirmationParams,
+ ) -> Result {
+ let cx = &mut self.cx.clone();
+
+ let old_acp_id = *self.next_tool_call_id.borrow() + 1;
+ self.next_tool_call_id.replace(old_acp_id);
+
+ let tool_call = into_new_tool_call(
+ acp::ToolCallId(old_acp_id.to_string().into()),
+ request.tool_call,
+ );
+
+ let mut options = match request.confirmation {
+ acp_old::ToolCallConfirmation::Edit { .. } => vec![(
+ acp_old::ToolCallConfirmationOutcome::AlwaysAllow,
+ acp::PermissionOptionKind::AllowAlways,
+ "Always Allow Edits".to_string(),
+ )],
+ acp_old::ToolCallConfirmation::Execute { root_command, .. } => vec![(
+ acp_old::ToolCallConfirmationOutcome::AlwaysAllow,
+ acp::PermissionOptionKind::AllowAlways,
+ format!("Always Allow {}", root_command),
+ )],
+ acp_old::ToolCallConfirmation::Mcp {
+ server_name,
+ tool_name,
+ ..
+ } => vec![
+ (
+ acp_old::ToolCallConfirmationOutcome::AlwaysAllowMcpServer,
+ acp::PermissionOptionKind::AllowAlways,
+ format!("Always Allow {}", server_name),
+ ),
+ (
+ acp_old::ToolCallConfirmationOutcome::AlwaysAllowTool,
+ acp::PermissionOptionKind::AllowAlways,
+ format!("Always Allow {}", tool_name),
+ ),
+ ],
+ acp_old::ToolCallConfirmation::Fetch { .. } => vec![(
+ acp_old::ToolCallConfirmationOutcome::AlwaysAllow,
+ acp::PermissionOptionKind::AllowAlways,
+ "Always Allow".to_string(),
+ )],
+ acp_old::ToolCallConfirmation::Other { .. } => vec![(
+ acp_old::ToolCallConfirmationOutcome::AlwaysAllow,
+ acp::PermissionOptionKind::AllowAlways,
+ "Always Allow".to_string(),
+ )],
+ };
+
+ options.extend([
+ (
+ acp_old::ToolCallConfirmationOutcome::Allow,
+ acp::PermissionOptionKind::AllowOnce,
+ "Allow".to_string(),
+ ),
+ (
+ acp_old::ToolCallConfirmationOutcome::Reject,
+ acp::PermissionOptionKind::RejectOnce,
+ "Reject".to_string(),
+ ),
+ ]);
+
+ let mut outcomes = Vec::with_capacity(options.len());
+ let mut acp_options = Vec::with_capacity(options.len());
+
+ for (index, (outcome, kind, label)) in options.into_iter().enumerate() {
+ outcomes.push(outcome);
+ acp_options.push(acp::PermissionOption {
+ id: acp::PermissionOptionId(index.to_string().into()),
+ name: label,
+ kind,
+ })
+ }
+
+ let response = cx
+ .update(|cx| {
+ self.thread.borrow().update(cx, |thread, cx| {
+ thread.request_tool_call_authorization(tool_call.into(), acp_options, cx)
+ })
+ })??
+ .context("Failed to update thread")?
+ .await;
+
+ let outcome = match response {
+ Ok(option_id) => outcomes[option_id.0.parse::().unwrap_or(0)],
+ Err(oneshot::Canceled) => acp_old::ToolCallConfirmationOutcome::Cancel,
+ };
+
+ Ok(acp_old::RequestToolCallConfirmationResponse {
+ id: acp_old::ToolCallId(old_acp_id),
+ outcome,
+ })
+ }
+
+ async fn push_tool_call(
+ &self,
+ request: acp_old::PushToolCallParams,
+ ) -> Result {
+ let cx = &mut self.cx.clone();
+
+ let old_acp_id = *self.next_tool_call_id.borrow() + 1;
+ self.next_tool_call_id.replace(old_acp_id);
+
+ cx.update(|cx| {
+ self.thread.borrow().update(cx, |thread, cx| {
+ thread.upsert_tool_call(
+ into_new_tool_call(acp::ToolCallId(old_acp_id.to_string().into()), request),
+ cx,
+ )
+ })
+ })??
+ .context("Failed to update thread")?;
+
+ Ok(acp_old::PushToolCallResponse {
+ id: acp_old::ToolCallId(old_acp_id),
+ })
+ }
+
+ async fn update_tool_call(
+ &self,
+ request: acp_old::UpdateToolCallParams,
+ ) -> Result<(), acp_old::Error> {
+ let cx = &mut self.cx.clone();
+
+ cx.update(|cx| {
+ self.thread.borrow().update(cx, |thread, cx| {
+ thread.update_tool_call(
+ acp::ToolCallUpdate {
+ id: acp::ToolCallId(request.tool_call_id.0.to_string().into()),
+ fields: acp::ToolCallUpdateFields {
+ status: Some(into_new_tool_call_status(request.status)),
+ content: Some(
+ request
+ .content
+ .into_iter()
+ .map(into_new_tool_call_content)
+ .collect::