trigger ci

Simplify docs for mac/linux/windows by consolidating the backend
dependencies (collaboration) docs into local-collaboration.md. Most
users building zed will not need to do this -- streamline them into
getting setup to build the zed client app first.

Release Notes:

- N/A

.github/actionlint.yml

@@ -0,0 +1,30 @@
+# Configuration related to self-hosted runner.
+self-hosted-runner:
+  # Labels of self-hosted runner in array of strings.
+  labels:
+    # GitHub-hosted Runners
+    - github-8vcpu-ubuntu-2404
+    - github-16vcpu-ubuntu-2404
+    - windows-2025-16
+    - windows-2025-32
+    - windows-2025-64
+    # Buildjet Ubuntu 20.04 - AMD x86_64
+    - buildjet-2vcpu-ubuntu-2004
+    - buildjet-4vcpu-ubuntu-2004
+    - buildjet-8vcpu-ubuntu-2004
+    - buildjet-16vcpu-ubuntu-2004
+    - buildjet-32vcpu-ubuntu-2004
+    # Buildjet Ubuntu 22.04 - AMD x86_64
+    - buildjet-2vcpu-ubuntu-2204
+    - buildjet-4vcpu-ubuntu-2204
+    - buildjet-8vcpu-ubuntu-2204
+    - buildjet-16vcpu-ubuntu-2204
+    - buildjet-32vcpu-ubuntu-2204
+    # Buildjet Ubuntu 22.04 - Graviton aarch64
+    - buildjet-8vcpu-ubuntu-2204-arm
+    - buildjet-16vcpu-ubuntu-2204-arm
+    - buildjet-32vcpu-ubuntu-2204-arm
+    - buildjet-64vcpu-ubuntu-2204-arm
+    # Self Hosted Runners
+    - self-mini-macos
+    - self-32vcpu-windows-2022

.github/workflows/bump_patch_version.yml

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

.github/workflows/ci.yml

@@ -34,6 +34,7 @@ jobs:
       run_license: ${{ steps.filter.outputs.run_license }}
       run_docs: ${{ steps.filter.outputs.run_docs }}
       run_nix: ${{ steps.filter.outputs.run_nix }}
+      run_actionlint: ${{ steps.filter.outputs.run_actionlint }}
     runs-on:
       - ubuntu-latest
     steps:
@@ -47,39 +48,40 @@ jobs:
         run: |
           if [ -z "$GITHUB_BASE_REF" ]; then
             echo "Not in a PR context (i.e., push to main/stable/preview)"
-            COMPARE_REV=$(git rev-parse HEAD~1)
+            COMPARE_REV="$(git rev-parse HEAD~1)"
           else
             echo "In a PR context comparing to pull_request.base.ref"
             git fetch origin "$GITHUB_BASE_REF" --depth=350
-            COMPARE_REV=$(git merge-base "origin/${GITHUB_BASE_REF}" HEAD)
+            COMPARE_REV="$(git merge-base "origin/${GITHUB_BASE_REF}" HEAD)"
           fi
-          # Specify anything which should skip full CI in this regex:
+          CHANGED_FILES="$(git diff --name-only "$COMPARE_REV" ${{ github.sha }})"
+
+          # Specify anything which should potentially skip full test suite in this regex:
           # - docs/
           # - script/update_top_ranking_issues/
           # - .github/ISSUE_TEMPLATE/
           # - .github/workflows/  (except .github/workflows/ci.yml)
           SKIP_REGEX='^(docs/|script/update_top_ranking_issues/|\.github/(ISSUE_TEMPLATE|workflows/(?!ci)))'
-          if [[ $(git diff --name-only $COMPARE_REV ${{ github.sha }} | grep -vP "$SKIP_REGEX") ]]; then
-            echo "run_tests=true" >> $GITHUB_OUTPUT
-          else
-            echo "run_tests=false" >> $GITHUB_OUTPUT
-          fi
-          if [[ $(git diff --name-only $COMPARE_REV ${{ github.sha }} | grep '^docs/') ]]; then
-            echo "run_docs=true" >> $GITHUB_OUTPUT
-          else
-            echo "run_docs=false" >> $GITHUB_OUTPUT
-          fi
-          if [[ $(git diff --name-only $COMPARE_REV ${{ github.sha }} | grep -P '^(Cargo.lock|script/.*licenses)') ]]; then
-            echo "run_license=true" >> $GITHUB_OUTPUT
-          else
-            echo "run_license=false" >> $GITHUB_OUTPUT
-          fi
-          NIX_REGEX='^(nix/|flake\.|Cargo\.|rust-toolchain.toml|\.cargo/config.toml)'
-          if [[ $(git diff --name-only $COMPARE_REV ${{ github.sha }} | grep -P "$NIX_REGEX") ]]; then
-            echo "run_nix=true" >> $GITHUB_OUTPUT
-          else
-            echo "run_nix=false" >> $GITHUB_OUTPUT
-          fi
+
+          echo "$CHANGED_FILES" | grep -qvP "$SKIP_REGEX" && \
+            echo "run_tests=true" >> "$GITHUB_OUTPUT" || \
+            echo "run_tests=false" >> "$GITHUB_OUTPUT"
+
+          echo "$CHANGED_FILES" | grep -qP '^docs/' && \
+            echo "run_docs=true" >> "$GITHUB_OUTPUT" || \
+            echo "run_docs=false" >> "$GITHUB_OUTPUT"
+
+          echo "$CHANGED_FILES" | grep -qP '^\.github/(workflows/|actions/|actionlint.yml)' && \
+            echo "run_actionlint=true" >> "$GITHUB_OUTPUT" || \
+            echo "run_actionlint=false" >> "$GITHUB_OUTPUT"
+
+          echo "$CHANGED_FILES" | grep -qP '^(Cargo.lock|script/.*licenses)' && \
+            echo "run_license=true" >> "$GITHUB_OUTPUT" || \
+            echo "run_license=false" >> "$GITHUB_OUTPUT"
+
+          echo "$CHANGED_FILES" | grep -qP '^(nix/|flake\.|Cargo\.|rust-toolchain.toml|\.cargo/config.toml)' && \
+            echo "run_nix=true" >> "$GITHUB_OUTPUT" || \
+            echo "run_nix=false" >> "$GITHUB_OUTPUT"
 
   migration_checks:
     name: Check Postgres and Protobuf migrations, mergability
@@ -89,8 +91,7 @@ jobs:
       needs.job_spec.outputs.run_tests == 'true'
     timeout-minutes: 60
     runs-on:
-      - self-hosted
-      - macOS
+      - self-mini-macos
     steps:
       - name: Checkout repo
         uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
@@ -112,11 +113,11 @@ jobs:
         run: |
           if [ -z "$GITHUB_BASE_REF" ];
           then
-            echo "BUF_BASE_BRANCH=$(git merge-base origin/main HEAD)" >> $GITHUB_ENV
+            echo "BUF_BASE_BRANCH=$(git merge-base origin/main HEAD)" >> "$GITHUB_ENV"
           else
             git checkout -B temp
-            git merge -q origin/$GITHUB_BASE_REF -m "merge main into temp"
-            echo "BUF_BASE_BRANCH=$GITHUB_BASE_REF" >> $GITHUB_ENV
+            git merge -q "origin/$GITHUB_BASE_REF" -m "merge main into temp"
+            echo "BUF_BASE_BRANCH=$GITHUB_BASE_REF" >> "$GITHUB_ENV"
           fi
 
       - uses: bufbuild/buf-setup-action@v1
@@ -140,7 +141,7 @@ jobs:
       - name: Checkout repo
         uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
       - name: Add Rust to the PATH
-        run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH
+        run: echo "$HOME/.cargo/bin" >> "$GITHUB_PATH"
       - name: Install cargo-hakari
         uses: clechasseur/rs-cargo@8435b10f6e71c2e3d4d3b7573003a8ce4bfc6386 # v2
         with:
@@ -178,7 +179,7 @@ jobs:
       - name: Prettier Check on /docs
         working-directory: ./docs
         run: |
-          pnpm dlx prettier@${PRETTIER_VERSION} . --check || {
+          pnpm dlx "prettier@${PRETTIER_VERSION}" . --check || {
             echo "To fix, run from the root of the Zed repo:"
             echo "  cd docs && pnpm dlx prettier@${PRETTIER_VERSION} . --write && cd .."
             false
@@ -188,7 +189,7 @@ jobs:
 
       - name: Prettier Check on default.json
         run: |
-          pnpm dlx prettier@${PRETTIER_VERSION} assets/settings/default.json --check || {
+          pnpm dlx "prettier@${PRETTIER_VERSION}" assets/settings/default.json --check || {
             echo "To fix, run from the root of the Zed repo:"
             echo "  pnpm dlx prettier@${PRETTIER_VERSION} assets/settings/default.json --write"
             false
@@ -234,6 +235,20 @@ jobs:
       - name: Build docs
         uses: ./.github/actions/build_docs
 
+  actionlint:
+    runs-on: ubuntu-latest
+    if: github.repository_owner == 'zed-industries' && needs.job_spec.outputs.run_actionlint == 'true'
+    needs: [job_spec]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Download actionlint
+        id: get_actionlint
+        run: bash <(curl https://raw.githubusercontent.com/rhysd/actionlint/main/scripts/download-actionlint.bash)
+        shell: bash
+      - name: Check workflow files
+        run: ${{ steps.get_actionlint.outputs.executable }} -color
+        shell: bash
+
   macos_tests:
     timeout-minutes: 60
     name: (macOS) Run Clippy and tests
@@ -242,8 +257,7 @@ jobs:
       github.repository_owner == 'zed-industries' &&
       needs.job_spec.outputs.run_tests == 'true'
     runs-on:
-      - self-hosted
-      - macOS
+      - self-mini-macos
     steps:
       - name: Checkout repo
         uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
@@ -312,7 +326,7 @@ jobs:
       - buildjet-16vcpu-ubuntu-2204
     steps:
       - name: Add Rust to the PATH
-        run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH
+        run: echo "$HOME/.cargo/bin" >> "$GITHUB_PATH"
 
       - name: Checkout repo
         uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
@@ -364,7 +378,7 @@ jobs:
       - buildjet-8vcpu-ubuntu-2204
     steps:
       - name: Add Rust to the PATH
-        run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH
+        run: echo "$HOME/.cargo/bin" >> "$GITHUB_PATH"
 
       - name: Checkout repo
         uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
@@ -444,6 +458,7 @@ jobs:
       - job_spec
       - style
       - check_docs
+      - actionlint
       - migration_checks
       # run_tests: If adding required tests, add them here and to script below.
       - workspace_hack
@@ -465,6 +480,11 @@ jobs:
           if [[ "${{ needs.job_spec.outputs.run_docs }}" == "true" ]]; then
             [[ "${{ needs.check_docs.result }}" != 'success' ]] && { RET_CODE=1; echo "docs checks failed"; }
           fi
+
+          if [[ "${{ needs.job_spec.outputs.run_actionlint }}" == "true" ]]; then
+            [[ "${{ needs.actionlint.result }}" != 'success' ]] && { RET_CODE=1; echo "actionlint checks failed"; }
+          fi
+
           # Only check test jobs if they were supposed to run
           if [[ "${{ needs.job_spec.outputs.run_tests }}" == "true" ]]; then
             [[ "${{ needs.workspace_hack.result }}"       != 'success' ]] && { RET_CODE=1; echo "Workspace Hack failed"; }
@@ -484,8 +504,7 @@ jobs:
     timeout-minutes: 120
     name: Create a macOS bundle
     runs-on:
-      - self-hosted
-      - bundle
+      - self-mini-macos
     if: |
       startsWith(github.ref, 'refs/tags/v')
       || contains(github.event.pull_request.labels.*.name, 'run-bundling')
@@ -748,7 +767,7 @@ jobs:
     timeout-minutes: 120
     name: Create a Windows installer
     runs-on: [self-hosted, Windows, X64]
-    if: ${{ startsWith(github.ref, 'refs/tags/v') || contains(github.event.pull_request.labels.*.name, 'run-bundling') }}
+    if: false && (startsWith(github.ref, 'refs/tags/v') || contains(github.event.pull_request.labels.*.name, 'run-bundling'))
     needs: [windows_tests]
     env:
       AZURE_TENANT_ID: ${{ secrets.AZURE_SIGNING_TENANT_ID }}
@@ -787,7 +806,7 @@ jobs:
       - name: Upload Artifacts to release
         uses: softprops/action-gh-release@de2c0eb89ae2a093876385947365aca7b0e5f844 # v1
         # Re-enable when we are ready to publish windows preview releases
-        if: false && ${{ !(contains(github.event.pull_request.labels.*.name, 'run-bundling')) && env.RELEASE_CHANNEL == 'preview' }} # upload only preview
+        if: ${{ !(contains(github.event.pull_request.labels.*.name, 'run-bundling')) && env.RELEASE_CHANNEL == 'preview' }} # upload only preview
         with:
           draft: true
           prerelease: ${{ env.RELEASE_CHANNEL == 'preview' }}
@@ -802,10 +821,9 @@ jobs:
       && endsWith(github.ref, '-pre') && !endsWith(github.ref, '.0-pre')
     needs: [bundle-mac, bundle-linux-x86_x64, bundle-linux-aarch64, bundle-windows-x64]
     runs-on:
-      - self-hosted
-      - bundle
+      - self-mini-macos
     steps:
       - name: gh release
-        run: gh release edit $GITHUB_REF_NAME --draft=false
+        run: gh release edit "$GITHUB_REF_NAME" --draft=false
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/community_release_actions.yml

@@ -18,7 +18,7 @@ jobs:
               URL="https://zed.dev/releases/stable/latest"
           fi
 
-          echo "URL=$URL" >> $GITHUB_OUTPUT
+          echo "URL=$URL" >> "$GITHUB_OUTPUT"
       - name: Get content
         uses: 2428392/gh-truncate-string-action@b3ff790d21cf42af3ca7579146eedb93c8fb0757 # v1.4.1
         id: get-content
@@ -50,9 +50,9 @@ jobs:
           PREVIEW_TAG="${VERSION}-pre"
 
           if git rev-parse "$PREVIEW_TAG" > /dev/null 2>&1; then
-              echo "was_promoted_from_preview=true" >> $GITHUB_OUTPUT
+              echo "was_promoted_from_preview=true" >> "$GITHUB_OUTPUT"
           else
-              echo "was_promoted_from_preview=false" >> $GITHUB_OUTPUT
+              echo "was_promoted_from_preview=false" >> "$GITHUB_OUTPUT"
           fi
 
       - name: Send release notes email

.github/workflows/deploy_collab.yml

@@ -79,12 +79,12 @@ jobs:
       - name: Build docker image
         run: |
           docker build -f Dockerfile-collab \
-            --build-arg GITHUB_SHA=$GITHUB_SHA \
-            --tag registry.digitalocean.com/zed/collab:$GITHUB_SHA \
+            --build-arg "GITHUB_SHA=$GITHUB_SHA" \
+            --tag "registry.digitalocean.com/zed/collab:$GITHUB_SHA" \
             .
 
       - name: Publish docker image
-        run: docker push registry.digitalocean.com/zed/collab:${GITHUB_SHA}
+        run: docker push "registry.digitalocean.com/zed/collab:${GITHUB_SHA}"
 
       - name: Prune Docker system
         run: docker system prune  --filter 'until=72h' -f
@@ -131,7 +131,8 @@ jobs:
           source script/lib/deploy-helpers.sh
           export_vars_for_environment $ZED_KUBE_NAMESPACE
 
-          export ZED_DO_CERTIFICATE_ID=$(doctl compute certificate list --format ID --no-header)
+          ZED_DO_CERTIFICATE_ID="$(doctl compute certificate list --format ID --no-header)"
+          export ZED_DO_CERTIFICATE_ID
           export ZED_IMAGE_ID="registry.digitalocean.com/zed/collab:${GITHUB_SHA}"
 
           export ZED_SERVICE_NAME=collab

.github/workflows/eval.yml

@@ -35,7 +35,7 @@ jobs:
       - buildjet-16vcpu-ubuntu-2204
     steps:
       - name: Add Rust to the PATH
-        run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH
+        run: echo "$HOME/.cargo/bin" >> "$GITHUB_PATH"
 
       - name: Checkout repo
         uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4

.github/workflows/nix.yml

@@ -43,8 +43,8 @@ jobs:
       - name: Set path
         if: ${{ ! matrix.system.install_nix }}
         run: |
-          echo "/nix/var/nix/profiles/default/bin" >> $GITHUB_PATH
-          echo "/Users/administrator/.nix-profile/bin" >> $GITHUB_PATH
+          echo "/nix/var/nix/profiles/default/bin" >> "$GITHUB_PATH"
+          echo "/Users/administrator/.nix-profile/bin" >> "$GITHUB_PATH"
 
       - uses: cachix/install-nix-action@02a151ada4993995686f9ed4f1be7cfbb229e56f # v31
         if: ${{ matrix.system.install_nix }}
@@ -56,11 +56,13 @@ jobs:
           name: zed
           authToken: "${{ secrets.CACHIX_AUTH_TOKEN }}"
           pushFilter: "${{ inputs.cachix-filter }}"
-          cachixArgs: '-v'
+          cachixArgs: "-v"
 
       - run: nix build .#${{ inputs.flake-output }} -L --accept-flake-config
 
       - name: Limit /nix/store to 50GB on macs
         if: ${{ ! matrix.system.install_nix }}
         run: |
-          [ $(du -sm /nix/store | cut -f1) -gt 50000 ] && nix-collect-garbage -d || :
+          if [ "$(du -sm /nix/store | cut -f1)" -gt 50000 ]; then
+            nix-collect-garbage -d || true
+          fi

.github/workflows/release_nightly.yml

@@ -85,8 +85,7 @@ jobs:
     name: Create a macOS bundle
     if: github.repository_owner == 'zed-industries'
     runs-on:
-      - self-hosted
-      - bundle
+      - self-mini-macos
     needs: tests
     env:
       MACOS_CERTIFICATE: ${{ secrets.MACOS_CERTIFICATE }}
@@ -132,7 +131,7 @@ jobs:
           clean: false
 
       - name: Add Rust to the PATH
-        run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH
+        run: echo "$HOME/.cargo/bin" >> "$GITHUB_PATH"
 
       - name: Install Linux dependencies
         run: ./script/linux && ./script/install-mold 2.34.0

.github/workflows/unit_evals.yml

@@ -26,7 +26,7 @@ jobs:
       - buildjet-16vcpu-ubuntu-2204
     steps:
       - name: Add Rust to the PATH
-        run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH
+        run: echo "$HOME/.cargo/bin" >> "$GITHUB_PATH"
 
       - name: Checkout repo
         uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4

Cargo.lock

@@ -3,10 +3,9 @@
 version = 4
 
 [[package]]
-name = "acp"
+name = "acp_thread"
 version = "0.1.0"
 dependencies = [
- "agent_servers",
  "agentic-coding-protocol",
  "anyhow",
  "assistant_tool",
@@ -21,6 +20,7 @@ dependencies = [
  "language",
  "markdown",
  "project",
+ "serde",
  "serde_json",
  "settings",
  "smol",
@@ -139,16 +139,30 @@ dependencies = [
 name = "agent_servers"
 version = "0.1.0"
 dependencies = [
+ "acp_thread",
+ "agentic-coding-protocol",
  "anyhow",
  "collections",
+ "context_server",
+ "env_logger 0.11.8",
  "futures 0.3.31",
  "gpui",
+ "indoc",
+ "itertools 0.14.0",
+ "language",
+ "log",
  "paths",
  "project",
  "schemars",
  "serde",
+ "serde_json",
  "settings",
+ "smol",
+ "strum 0.27.1",
+ "tempfile",
+ "ui",
  "util",
+ "watch",
  "which 6.0.3",
  "workspace-hack",
 ]
@@ -176,11 +190,12 @@ dependencies = [
 name = "agent_ui"
 version = "0.1.0"
 dependencies = [
- "acp",
+ "acp_thread",
  "agent",
  "agent_servers",
  "agent_settings",
  "agentic-coding-protocol",
+ "ai_onboarding",
  "anyhow",
  "assistant_context",
  "assistant_slash_command",
@@ -315,6 +330,22 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "ai_onboarding"
+version = "0.1.0"
+dependencies = [
+ "client",
+ "component",
+ "gpui",
+ "language_model",
+ "proto",
+ "serde",
+ "smallvec",
+ "ui",
+ "workspace-hack",
+ "zed_actions",
+]
+
 [[package]]
 name = "alacritty_terminal"
 version = "0.25.1-dev"
@@ -2148,7 +2179,7 @@ dependencies = [
 [[package]]
 name = "blade-graphics"
 version = "0.6.0"
-source = "git+https://github.com/kvark/blade?rev=416375211bb0b5826b3584dccdb6a43369e499ad#416375211bb0b5826b3584dccdb6a43369e499ad"
+source = "git+https://github.com/kvark/blade?rev=e0ec4e720957edd51b945b64dd85605ea54bcfe5#e0ec4e720957edd51b945b64dd85605ea54bcfe5"
 dependencies = [
  "ash",
  "ash-window",
@@ -2181,7 +2212,7 @@ dependencies = [
 [[package]]
 name = "blade-macros"
 version = "0.3.0"
-source = "git+https://github.com/kvark/blade?rev=416375211bb0b5826b3584dccdb6a43369e499ad#416375211bb0b5826b3584dccdb6a43369e499ad"
+source = "git+https://github.com/kvark/blade?rev=e0ec4e720957edd51b945b64dd85605ea54bcfe5#e0ec4e720957edd51b945b64dd85605ea54bcfe5"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2191,7 +2222,7 @@ dependencies = [
 [[package]]
 name = "blade-util"
 version = "0.2.0"
-source = "git+https://github.com/kvark/blade?rev=416375211bb0b5826b3584dccdb6a43369e499ad#416375211bb0b5826b3584dccdb6a43369e499ad"
+source = "git+https://github.com/kvark/blade?rev=e0ec4e720957edd51b945b64dd85605ea54bcfe5#e0ec4e720957edd51b945b64dd85605ea54bcfe5"
 dependencies = [
  "blade-graphics",
  "bytemuck",
@@ -3411,12 +3442,14 @@ dependencies = [
  "futures 0.3.31",
  "gpui",
  "log",
+ "net",
  "parking_lot",
  "postage",
  "schemars",
  "serde",
  "serde_json",
  "smol",
+ "tempfile",
  "url",
  "util",
  "workspace-hack",
@@ -4232,6 +4265,7 @@ dependencies = [
  "serde",
  "serde_json",
  "shlex",
+ "smol",
  "task",
  "util",
  "workspace-hack",
@@ -4412,6 +4446,7 @@ dependencies = [
  "pretty_assertions",
  "project",
  "rpc",
+ "schemars",
  "serde",
  "serde_json",
  "serde_json_lenient",
@@ -9048,6 +9083,7 @@ dependencies = [
 name = "language_models"
 version = "0.1.0"
 dependencies = [
+ "ai_onboarding",
  "anthropic",
  "anyhow",
  "aws-config",
@@ -9689,7 +9725,7 @@ dependencies = [
 [[package]]
 name = "lsp-types"
 version = "0.95.1"
-source = "git+https://github.com/zed-industries/lsp-types?rev=6add7052b598ea1f40f7e8913622c3958b009b60#6add7052b598ea1f40f7e8913622c3958b009b60"
+source = "git+https://github.com/zed-industries/lsp-types?rev=39f629bdd03d59abd786ed9fc27e8bca02c0c0ec#39f629bdd03d59abd786ed9fc27e8bca02c0c0ec"
 dependencies = [
  "bitflags 1.3.2",
  "serde",
@@ -10288,6 +10324,17 @@ dependencies = [
  "uuid",
 ]
 
+[[package]]
+name = "nc"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "futures 0.3.31",
+ "net",
+ "smol",
+ "workspace-hack",
+]
+
 [[package]]
 name = "ndk"
 version = "0.8.0"
@@ -20171,6 +20218,7 @@ dependencies = [
  "menu",
  "migrator",
  "mimalloc",
+ "nc",
  "nix 0.29.0",
  "node_runtime",
  "notifications",
@@ -20480,6 +20528,7 @@ dependencies = [
 name = "zeta"
 version = "0.1.0"
 dependencies = [
+ "ai_onboarding",
  "anyhow",
  "arrayvec",
  "call",
@@ -20487,6 +20536,7 @@ dependencies = [
  "clock",
  "collections",
  "command_palette_hooks",
+ "copilot",
  "ctor",
  "db",
  "editor",
@@ -20501,8 +20551,6 @@ dependencies = [
  "language_model",
  "log",
  "menu",
- "migrator",
- "paths",
  "postage",
  "project",
  "proto",

Cargo.toml

@@ -2,10 +2,11 @@
 resolver = "2"
 members = [
     "crates/activity_indicator",
-    "crates/acp",
+    "crates/acp_thread",
     "crates/agent_ui",
     "crates/agent",
     "crates/agent_settings",
+    "crates/ai_onboarding",
     "crates/agent_servers",
     "crates/anthropic",
     "crates/askpass",
@@ -102,6 +103,7 @@ members = [
     "crates/migrator",
     "crates/mistral",
     "crates/multi_buffer",
+    "crates/nc",
     "crates/net",
     "crates/node_runtime",
     "crates/notifications",
@@ -219,13 +221,14 @@ edition = "2024"
 # Workspace member crates
 #
 
-acp = { path = "crates/acp" }
+acp_thread = { path = "crates/acp_thread" }
 agent = { path = "crates/agent" }
 activity_indicator = { path = "crates/activity_indicator" }
 agent_ui = { path = "crates/agent_ui" }
 agent_settings = { path = "crates/agent_settings" }
 agent_servers = { path = "crates/agent_servers" }
 ai = { path = "crates/ai" }
+ai_onboarding = { path = "crates/ai_onboarding" }
 anthropic = { path = "crates/anthropic" }
 askpass = { path = "crates/askpass" }
 assets = { path = "crates/assets" }
@@ -317,6 +320,7 @@ menu = { path = "crates/menu" }
 migrator = { path = "crates/migrator" }
 mistral = { path = "crates/mistral" }
 multi_buffer = { path = "crates/multi_buffer" }
+nc = { path = "crates/nc" }
 net = { path = "crates/net" }
 node_runtime = { path = "crates/node_runtime" }
 notifications = { path = "crates/notifications" }
@@ -406,7 +410,7 @@ zlog_settings = { path = "crates/zlog_settings" }
 # External crates
 #
 
-agentic-coding-protocol = { version = "0.0.9" }
+agentic-coding-protocol = "0.0.9"
 aho-corasick = "1.1"
 alacritty_terminal = { git = "https://github.com/zed-industries/alacritty.git", branch = "add-hush-login-flag" }
 any_vec = "0.14"
@@ -434,9 +438,9 @@ 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"
 bitflags = "2.6.0"
-blade-graphics = { git = "https://github.com/kvark/blade", rev = "416375211bb0b5826b3584dccdb6a43369e499ad" }
-blade-macros = { git = "https://github.com/kvark/blade", rev = "416375211bb0b5826b3584dccdb6a43369e499ad" }
-blade-util = { git = "https://github.com/kvark/blade", rev = "416375211bb0b5826b3584dccdb6a43369e499ad" }
+blade-graphics = { git = "https://github.com/kvark/blade", rev = "e0ec4e720957edd51b945b64dd85605ea54bcfe5" }
+blade-macros = { git = "https://github.com/kvark/blade", rev = "e0ec4e720957edd51b945b64dd85605ea54bcfe5" }
+blade-util = { git = "https://github.com/kvark/blade", rev = "e0ec4e720957edd51b945b64dd85605ea54bcfe5" }
 blake3 = "1.5.3"
 bytes = "1.0"
 cargo_metadata = "0.19"
@@ -489,18 +493,18 @@ json_dotpath = "1.1"
 jsonschema = "0.30.0"
 jsonwebtoken = "9.3"
 jupyter-protocol = { git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734" }
-jupyter-websocket-client = { git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734" }
+jupyter-websocket-client = {  git = "https://github.com/ConradIrwin/runtimed" ,rev = "7130c804216b6914355d15d0b91ea91f6babd734" }
 libc = "0.2"
 libsqlite3-sys = { version = "0.30.1", features = ["bundled"] }
 linkify = "0.10.0"
 log = { version = "0.4.16", features = ["kv_unstable_serde", "serde"] }
-lsp-types = { git = "https://github.com/zed-industries/lsp-types", rev = "6add7052b598ea1f40f7e8913622c3958b009b60" }
+lsp-types = { git = "https://github.com/zed-industries/lsp-types", rev = "39f629bdd03d59abd786ed9fc27e8bca02c0c0ec" }
 markup5ever_rcdom = "0.3.0"
 metal = "0.29"
 moka = { version = "0.12.10", features = ["sync"] }
 naga = { version = "25.0", features = ["wgsl-in"] }
 nanoid = "0.4"
-nbformat = { git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734" }
+nbformat = {  git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734" }
 nix = "0.29"
 num-format = "0.4.4"
 objc = "0.2"
@@ -541,7 +545,7 @@ reqwest = { git = "https://github.com/zed-industries/reqwest.git", rev = "951c77
     "stream",
 ] }
 rsa = "0.9.6"
-runtimelib = { git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734", default-features = false, features = [
+runtimelib = {  git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734", default-features = false, features = [
     "async-dispatcher-runtime",
 ] }
 rust-embed = { version = "8.4", features = ["include-exclude"] }

assets/icons/ai_claude.svg

@@ -0,0 +1,3 @@
+<svg width="40" height="40" viewBox="0 0 40 40" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M7.8481 26.5925L15.7165 22.1806L15.8481 21.7961L15.7165 21.5836H15.3316L14.0152 21.5027L9.51899 21.3812L5.62025 21.2193L1.84304 21.0169L0.891139 20.8146L0 19.6408L0.0911392 19.0539L0.891139 18.5176L2.03544 18.6188L4.56709 18.7908L8.36456 19.0539L11.119 19.2158L15.2 19.6408H15.8481L15.9392 19.3777L15.7165 19.2158L15.5443 19.0539L11.6152 16.3926L7.36203 13.5796L5.13418 11.9605L3.92911 11.1409L3.32152 10.3719L3.05823 8.69213L4.1519 7.48798L5.62025 7.58917L5.99494 7.69036L7.48354 8.8338L10.6633 11.2927L14.8152 14.3486L15.4228 14.8545L15.6658 14.6825L15.6962 14.5611L15.4228 14.1057L13.1646 10.0278L10.7544 5.87908L9.68101 4.15887L9.39747 3.12674C9.2962 2.70175 9.22532 2.34758 9.22532 1.91247L10.4709 0.222616L11.1595 0L12.8203 0.222616L13.519 0.82975L14.5519 3.18745L16.2228 6.90109L18.8152 11.9504L19.5747 13.448L19.9797 14.8343L20.1316 15.2593H20.3949V15.0164L20.6076 12.173L21.0025 8.68201L21.3873 4.18922L21.519 2.92436L22.1468 1.40653L23.3924 0.586896L24.3646 1.05237L25.1646 2.1958L25.0532 2.93448L24.5772 6.02074L23.6456 10.8576L23.038 14.0956H23.3924L23.7975 13.6909L25.438 11.5153L28.1924 8.07488L29.4076 6.70883L30.8253 5.20111L31.7367 4.48267H33.4582L34.7241 6.36479L34.157 8.30761L32.3848 10.554L30.9165 12.4564L28.8101 15.2897L27.4937 17.5563L27.6152 17.7384L27.9291 17.7081L32.6886 16.6962L35.2608 16.2307L38.3291 15.7045L39.7165 16.3521L39.8684 17.0099L39.3215 18.3557L36.0405 19.1652L32.1924 19.9342L26.4608 21.2902L26.3899 21.3408L26.4709 21.4419L29.0532 21.6848L30.157 21.7455H32.8608L37.8937 22.1199L39.2101 22.9901L40 24.0526L39.8684 24.8621L37.843 25.8943L35.1089 25.2466L28.7291 23.7288L26.5418 23.1824H26.238V23.3645L28.0608 25.1455L31.4025 28.1609L35.5848 32.0465L35.7975 33.0078L35.2608 33.7668L34.6937 33.6858L31.0177 30.9233L29.6 29.6787L26.3899 26.977H26.1772V27.2603L26.9165 28.343L30.8253 34.212L31.0278 36.0132L30.7443 36.6L29.7316 36.9542L28.6177 36.7518L26.3291 33.5441L23.9696 29.9317L22.0658 26.6937L21.8329 26.8252L20.7089 38.9173L20.1823 39.5345L18.9671 40L17.9544 39.231L17.4177 37.9863L17.9544 35.5274L18.6025 32.3198L19.1291 29.7698L19.6051 26.6026L19.8886 25.5502L19.8684 25.4794L19.6354 25.5097L17.2456 28.7883L13.6101 33.6959L10.7342 36.7721L10.0456 37.0453L8.85063 36.428L8.96203 35.3251L9.63038 34.3435L13.6101 29.2841L16.0101 26.1472L17.5595 24.3359L17.5494 24.0729H17.4582L6.88608 30.9335L5.00253 31.1763L4.1924 30.4174L4.29367 29.1728L4.67848 28.768L7.85823 26.5823L7.8481 26.5925Z" fill="black"/>
+</svg>

assets/icons/ai_open_router.svg

@@ -1,5 +1,5 @@
 <svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor" stroke="currentColor">
-  <g clip-path="url(#clip0_205_3)">
+  <g>
     <path d="M0.094 7.78c0.469 0 2.281 -0.405 3.219 -0.936s0.938 -0.531 2.875 -1.906c2.453 -1.741 4.188 -1.158 7.031 -1.158" stroke-width="2.8125" />
     <path d="m15.969 3.797 -4.805 2.774V1.023z" />
     <path d="M0 7.781c0.469 0 2.281 0.405 3.219 0.936s0.938 0.531 2.875 1.906C8.547 12.364 10.281 11.781 13.125 11.781" stroke-width="2.8125" />

assets/keymaps/default-linux.json

@@ -269,15 +269,15 @@
     }
   },
   {
-    "context": "AgentPanel && acp_thread",
+    "context": "AgentPanel && external_agent_thread",
     "use_key_equivalents": true,
     "bindings": {
-      "ctrl-n": "agent::NewAcpThread",
+      "ctrl-n": "agent::NewExternalAgentThread",
       "ctrl-alt-t": "agent::NewThread"
     }
   },
   {
-    "context": "MessageEditor > Editor",
+    "context": "MessageEditor > Editor && !use_modifier_to_send",
     "bindings": {
       "enter": "agent::Chat",
       "ctrl-enter": "agent::ChatWithFollow",
@@ -287,6 +287,17 @@
       "ctrl-shift-n": "agent::RejectAll"
     }
   },
+  {
+    "context": "MessageEditor > Editor && use_modifier_to_send",
+    "bindings": {
+      "ctrl-enter": "agent::Chat",
+      "enter": "editor::Newline",
+      "ctrl-i": "agent::ToggleProfileSelector",
+      "shift-ctrl-r": "agent::OpenAgentDiff",
+      "ctrl-shift-y": "agent::KeepAll",
+      "ctrl-shift-n": "agent::RejectAll"
+    }
+  },
   {
     "context": "EditMessageEditor > Editor",
     "bindings": {
@@ -419,7 +430,7 @@
       "ctrl-shift-pagedown": "pane::SwapItemRight",
       "ctrl-f4": ["pane::CloseActiveItem", { "close_pinned": false }],
       "ctrl-w": ["pane::CloseActiveItem", { "close_pinned": false }],
-      "alt-ctrl-t": ["pane::CloseInactiveItems", { "close_pinned": false }],
+      "alt-ctrl-t": ["pane::CloseOtherItems", { "close_pinned": false }],
       "alt-ctrl-shift-w": "workspace::CloseInactiveTabsAndPanes",
       "ctrl-k e": ["pane::CloseItemsToTheLeft", { "close_pinned": false }],
       "ctrl-k t": ["pane::CloseItemsToTheRight", { "close_pinned": false }],
@@ -917,7 +928,7 @@
     }
   },
   {
-    "context": "GitPanel > Editor",
+    "context": "CommitEditor > Editor",
     "bindings": {
       "escape": "git_panel::FocusChanges",
       "tab": "git_panel::FocusChanges",
@@ -1118,7 +1129,9 @@
       "ctrl-f": "search::FocusSearch",
       "alt-find": "keymap_editor::ToggleKeystrokeSearch",
       "alt-ctrl-f": "keymap_editor::ToggleKeystrokeSearch",
-      "alt-c": "keymap_editor::ToggleConflictFilter"
+      "alt-c": "keymap_editor::ToggleConflictFilter",
+      "enter": "keymap_editor::EditBinding",
+      "alt-enter": "keymap_editor::CreateBinding"
     }
   },
   {

assets/keymaps/default-macos.json

@@ -310,15 +310,15 @@
     }
   },
   {
-    "context": "AgentPanel && acp_thread",
+    "context": "AgentPanel && external_agent_thread",
     "use_key_equivalents": true,
     "bindings": {
-      "cmd-n": "agent::NewAcpThread",
+      "cmd-n": "agent::NewExternalAgentThread",
       "cmd-alt-t": "agent::NewThread"
     }
   },
   {
-    "context": "MessageEditor > Editor",
+    "context": "MessageEditor > Editor && !use_modifier_to_send",
     "use_key_equivalents": true,
     "bindings": {
       "enter": "agent::Chat",
@@ -329,6 +329,18 @@
       "cmd-shift-n": "agent::RejectAll"
     }
   },
+  {
+    "context": "MessageEditor > Editor && use_modifier_to_send",
+    "use_key_equivalents": true,
+    "bindings": {
+      "cmd-enter": "agent::Chat",
+      "enter": "editor::Newline",
+      "cmd-i": "agent::ToggleProfileSelector",
+      "shift-ctrl-r": "agent::OpenAgentDiff",
+      "cmd-shift-y": "agent::KeepAll",
+      "cmd-shift-n": "agent::RejectAll"
+    }
+  },
   {
     "context": "EditMessageEditor > Editor",
     "use_key_equivalents": true,
@@ -477,7 +489,7 @@
       "ctrl-shift-pageup": "pane::SwapItemLeft",
       "ctrl-shift-pagedown": "pane::SwapItemRight",
       "cmd-w": ["pane::CloseActiveItem", { "close_pinned": false }],
-      "alt-cmd-t": ["pane::CloseInactiveItems", { "close_pinned": false }],
+      "alt-cmd-t": ["pane::CloseOtherItems", { "close_pinned": false }],
       "ctrl-alt-cmd-w": "workspace::CloseInactiveTabsAndPanes",
       "cmd-k e": ["pane::CloseItemsToTheLeft", { "close_pinned": false }],
       "cmd-k t": ["pane::CloseItemsToTheRight", { "close_pinned": false }],
@@ -963,7 +975,7 @@
     }
   },
   {
-    "context": "GitPanel > Editor",
+    "context": "CommitEditor > Editor",
     "use_key_equivalents": true,
     "bindings": {
       "enter": "editor::Newline",
@@ -1217,7 +1229,9 @@
     "use_key_equivalents": true,
     "bindings": {
       "cmd-alt-f": "keymap_editor::ToggleKeystrokeSearch",
-      "cmd-alt-c": "keymap_editor::ToggleConflictFilter"
+      "cmd-alt-c": "keymap_editor::ToggleConflictFilter",
+      "enter": "keymap_editor::EditBinding",
+      "alt-enter": "keymap_editor::CreateBinding"
     }
   },
   {

assets/keymaps/linux/emacs.json

@@ -114,7 +114,7 @@
       "ctrl-x o": "workspace::ActivateNextPane", // other-window
       "ctrl-x k": "pane::CloseActiveItem", // kill-buffer
       "ctrl-x 0": "pane::CloseActiveItem", // delete-window
-      "ctrl-x 1": "pane::CloseInactiveItems", // delete-other-windows
+      "ctrl-x 1": "pane::CloseOtherItems", // delete-other-windows
       "ctrl-x 2": "pane::SplitDown", // split-window-below
       "ctrl-x 3": "pane::SplitRight", // split-window-right
       "ctrl-x ctrl-f": "file_finder::Toggle", // find-file

assets/keymaps/linux/jetbrains.json

@@ -66,22 +66,51 @@
     "context": "Editor && mode == full",
     "bindings": {
       "ctrl-f12": "outline::Toggle",
-      "alt-7": "outline::Toggle",
+      "ctrl-r": ["buffer_search::Deploy", { "replace_enabled": true }],
       "ctrl-shift-n": "file_finder::Toggle",
       "ctrl-g": "go_to_line::Toggle",
       "alt-enter": "editor::ToggleCodeActions"
     }
   },
+  {
+    "context": "BufferSearchBar",
+    "bindings": {
+      "shift-enter": "search::SelectPreviousMatch"
+    }
+  },
+  {
+    "context": "BufferSearchBar || ProjectSearchBar",
+    "bindings": {
+      "alt-c": "search::ToggleCaseSensitive",
+      "alt-e": "search::ToggleSelection",
+      "alt-x": "search::ToggleRegex",
+      "alt-w": "search::ToggleWholeWord"
+    }
+  },
   {
     "context": "Workspace",
     "bindings": {
+      "ctrl-shift-f12": "workspace::CloseAllDocks",
+      "ctrl-shift-r": ["pane::DeploySearch", { "replace_enabled": true }],
+      "alt-shift-f10": "task::Spawn",
+      "ctrl-e": "file_finder::Toggle",
+      "ctrl-k": "git_panel::ToggleFocus", // bug: This should also focus commit editor
       "ctrl-shift-n": "file_finder::Toggle",
       "ctrl-shift-a": "command_palette::Toggle",
       "shift shift": "command_palette::Toggle",
       "ctrl-alt-shift-n": "project_symbols::Toggle",
+      "alt-0": "git_panel::ToggleFocus",
       "alt-1": "workspace::ToggleLeftDock",
-      "ctrl-e": "tab_switcher::Toggle",
-      "alt-6": "diagnostics::Deploy"
+      "alt-5": "debug_panel::ToggleFocus",
+      "alt-6": "diagnostics::Deploy",
+      "alt-7": "outline_panel::ToggleFocus"
+    }
+  },
+  {
+    "context": "Workspace || Editor",
+    "bindings": {
+      "alt-f12": "terminal_panel::ToggleFocus",
+      "ctrl-shift-k": "git::Push"
     }
   },
   {
@@ -95,10 +124,33 @@
     "context": "ProjectPanel",
     "bindings": {
       "enter": "project_panel::Open",
+      "ctrl-shift-f": "project_panel::NewSearchInDirectory",
       "backspace": ["project_panel::Trash", { "skip_prompt": false }],
       "delete": ["project_panel::Trash", { "skip_prompt": false }],
       "shift-delete": ["project_panel::Delete", { "skip_prompt": false }],
       "shift-f6": "project_panel::Rename"
     }
+  },
+  {
+    "context": "Terminal",
+    "bindings": {
+      "ctrl-shift-t": "workspace::NewTerminal",
+      "alt-f12": "workspace::CloseActiveDock",
+      "alt-left": "pane::ActivatePreviousItem",
+      "alt-right": "pane::ActivateNextItem",
+      "ctrl-up": "terminal::ScrollLineUp",
+      "ctrl-down": "terminal::ScrollLineDown",
+      "shift-pageup": "terminal::ScrollPageUp",
+      "shift-pagedown": "terminal::ScrollPageDown"
+    }
+  },
+  { "context": "GitPanel", "bindings": { "alt-0": "workspace::CloseActiveDock" } },
+  { "context": "ProjectPanel", "bindings": { "alt-1": "workspace::CloseActiveDock" } },
+  { "context": "DebugPanel", "bindings": { "alt-5": "workspace::CloseActiveDock" } },
+  { "context": "Diagnostics > Editor", "bindings": { "alt-6": "pane::CloseActiveItem" } },
+  { "context": "OutlinePanel", "bindings": { "alt-7": "workspace::CloseActiveDock" } },
+  {
+    "context": "Dock || Workspace || Terminal || OutlinePanel || ProjectPanel || CollabPanel || (Editor && mode == auto_height)",
+    "bindings": { "escape": "editor::ToggleFocus" }
   }
 ]

assets/keymaps/macos/emacs.json

@@ -114,7 +114,7 @@
       "ctrl-x o": "workspace::ActivateNextPane", // other-window
       "ctrl-x k": "pane::CloseActiveItem", // kill-buffer
       "ctrl-x 0": "pane::CloseActiveItem", // delete-window
-      "ctrl-x 1": "pane::CloseInactiveItems", // delete-other-windows
+      "ctrl-x 1": "pane::CloseOtherItems", // delete-other-windows
       "ctrl-x 2": "pane::SplitDown", // split-window-below
       "ctrl-x 3": "pane::SplitRight", // split-window-right
       "ctrl-x ctrl-f": "file_finder::Toggle", // find-file

assets/keymaps/macos/jetbrains.json

@@ -3,6 +3,7 @@
     "bindings": {
       "cmd-{": "pane::ActivatePreviousItem",
       "cmd-}": "pane::ActivateNextItem",
+      "cmd-0": "git_panel::ToggleFocus", // overrides `cmd-0` zoom reset
       "ctrl-f2": "debugger::Stop",
       "f6": "debugger::Pause",
       "f7": "debugger::StepInto",
@@ -63,28 +64,55 @@
     "context": "Editor && mode == full",
     "bindings": {
       "cmd-f12": "outline::Toggle",
-      "cmd-7": "outline::Toggle",
+      "cmd-r": ["buffer_search::Deploy", { "replace_enabled": true }],
       "cmd-shift-o": "file_finder::Toggle",
       "cmd-l": "go_to_line::Toggle",
       "alt-enter": "editor::ToggleCodeActions"
     }
   },
   {
-    "context": "BufferSearchBar > Editor",
+    "context": "BufferSearchBar",
     "bindings": {
       "shift-enter": "search::SelectPreviousMatch"
     }
   },
+  {
+    "context": "BufferSearchBar || ProjectSearchBar",
+    "bindings": {
+      "alt-c": "search::ToggleCaseSensitive",
+      "alt-e": "search::ToggleSelection",
+      "alt-x": "search::ToggleRegex",
+      "alt-w": "search::ToggleWholeWord",
+      "ctrl-alt-c": "search::ToggleCaseSensitive",
+      "ctrl-alt-e": "search::ToggleSelection",
+      "ctrl-alt-w": "search::ToggleWholeWord",
+      "ctrl-alt-x": "search::ToggleRegex"
+    }
+  },
   {
     "context": "Workspace",
     "bindings": {
+      "cmd-shift-f12": "workspace::CloseAllDocks",
+      "cmd-shift-r": ["pane::DeploySearch", { "replace_enabled": true }],
+      "ctrl-alt-r": "task::Spawn",
+      "cmd-e": "file_finder::Toggle",
+      "cmd-k": "git_panel::ToggleFocus", // bug: This should also focus commit editor
       "cmd-shift-o": "file_finder::Toggle",
       "cmd-shift-a": "command_palette::Toggle",
       "shift shift": "command_palette::Toggle",
       "cmd-alt-o": "project_symbols::Toggle", // JetBrains: Go to Symbol
       "cmd-o": "project_symbols::Toggle", // JetBrains: Go to Class
-      "cmd-1": "workspace::ToggleLeftDock",
-      "cmd-6": "diagnostics::Deploy"
+      "cmd-1": "project_panel::ToggleFocus",
+      "cmd-5": "debug_panel::ToggleFocus",
+      "cmd-6": "diagnostics::Deploy",
+      "cmd-7": "outline_panel::ToggleFocus"
+    }
+  },
+  {
+    "context": "Workspace || Editor",
+    "bindings": {
+      "alt-f12": "terminal_panel::ToggleFocus",
+      "cmd-shift-k": "git::Push"
     }
   },
   {
@@ -98,11 +126,31 @@
     "context": "ProjectPanel",
     "bindings": {
       "enter": "project_panel::Open",
+      "cmd-shift-f": "project_panel::NewSearchInDirectory",
       "cmd-backspace": ["project_panel::Trash", { "skip_prompt": false }],
       "backspace": ["project_panel::Trash", { "skip_prompt": false }],
       "delete": ["project_panel::Trash", { "skip_prompt": false }],
       "shift-delete": ["project_panel::Delete", { "skip_prompt": false }],
       "shift-f6": "project_panel::Rename"
     }
+  },
+  {
+    "context": "Terminal",
+    "bindings": {
+      "cmd-t": "workspace::NewTerminal",
+      "alt-f12": "workspace::CloseActiveDock",
+      "cmd-up": "terminal::ScrollLineUp",
+      "cmd-down": "terminal::ScrollLineDown",
+      "shift-pageup": "terminal::ScrollPageUp",
+      "shift-pagedown": "terminal::ScrollPageDown"
+    }
+  },
+  { "context": "GitPanel", "bindings": { "cmd-0": "workspace::CloseActiveDock" } },
+  { "context": "DebugPanel", "bindings": { "cmd-5": "workspace::CloseActiveDock" } },
+  { "context": "Diagnostics > Editor", "bindings": { "cmd-6": "pane::CloseActiveItem" } },
+  { "context": "OutlinePanel", "bindings": { "cmd-7": "workspace::CloseActiveDock" } },
+  {
+    "context": "Dock || Workspace || Terminal || OutlinePanel || ProjectPanel || CollabPanel || (Editor && mode == auto_height)",
+    "bindings": { "escape": "editor::ToggleFocus" }
   }
 ]

assets/keymaps/vim.json

@@ -377,6 +377,7 @@
     "context": "vim_mode == helix_normal && !menu",
     "bindings": {
       "ctrl-[": "editor::Cancel",
+      ";": "vim::HelixCollapseSelection",
       ":": "command_palette::Toggle",
       "left": "vim::WrappingLeft",
       "right": "vim::WrappingRight",
@@ -723,7 +724,7 @@
     }
   },
   {
-    "context": "AgentPanel || GitPanel || ProjectPanel || CollabPanel || OutlinePanel || ChatPanel || VimControl || EmptyPane || SharedScreen || MarkdownPreview || KeyContextView || DebugPanel",
+    "context": "VimControl || !Editor && !Terminal",
     "bindings": {
       // window related commands (ctrl-w X)
       "ctrl-w": null,
@@ -781,7 +782,7 @@
     }
   },
   {
-    "context": "ChangesList || EmptyPane || SharedScreen || MarkdownPreview || KeyContextView || Welcome",
+    "context": "!Editor && !Terminal",
     "bindings": {
       ":": "command_palette::Toggle",
       "g /": "pane::DeploySearch"

assets/settings/default.json

@@ -197,6 +197,8 @@
   //    "inline"
   // 3. Place snippets at the bottom of the completion list:
   //    "bottom"
+  // 4. Do not show snippets in the completion list:
+  //    "none"
   "snippet_sort_order": "inline",
   // How to highlight the current line in the editor.
   //
@@ -817,7 +819,7 @@
           "edit_file": true,
           "fetch": true,
           "list_directory": true,
-          "project_notifications": true,
+          "project_notifications": false,
           "move_path": true,
           "now": true,
           "find_path": true,
@@ -837,7 +839,7 @@
           "diagnostics": true,
           "fetch": true,
           "list_directory": true,
-          "project_notifications": true,
+          "project_notifications": false,
           "now": true,
           "find_path": true,
           "read_file": true,

assets/settings/initial_user_settings.json

@@ -8,7 +8,7 @@
 // command palette (cmd-shift-p / ctrl-shift-p)
 {
   "ui_font_size": 16,
-  "buffer_font_size": 16,
+  "buffer_font_size": 15,
   "theme": {
     "mode": "system",
     "light": "One Light",

compose.yml

@@ -59,5 +59,11 @@ services:
     depends_on:
       - postgres
 
+  stripe-mock:
+    image: stripe/stripe-mock:v0.184.0
+    ports:
+      - 12111:12111
+      - 12112:12112
+
 volumes:
   postgres_data:

crates/acp_thread/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "acp"
+name = "acp_thread"
 version = "0.1.0"
 edition.workspace = true
 publish.workspace = true
@@ -9,15 +9,13 @@ license = "GPL-3.0-or-later"
 workspace = true
 
 [lib]
-path = "src/acp.rs"
+path = "src/acp_thread.rs"
 doctest = false
 
 [features]
 test-support = ["gpui/test-support", "project/test-support"]
-gemini = []
 
 [dependencies]
-agent_servers.workspace = true
 agentic-coding-protocol.workspace = true
 anyhow.workspace = true
 assistant_tool.workspace = true
@@ -29,6 +27,8 @@ itertools.workspace = true
 language.workspace = true
 markdown.workspace = true
 project.workspace = true
+serde.workspace = true
+serde_json.workspace = true
 settings.workspace = true
 smol.workspace = true
 ui.workspace = true
@@ -41,7 +41,6 @@ env_logger.workspace = true
 gpui = { workspace = true, "features" = ["test-support"] }
 indoc.workspace = true
 project = { workspace = true, "features" = ["test-support"] }
-serde_json.workspace = true
 tempfile.workspace = true
 util.workspace = true
 settings.workspace = true

crates/acp_thread/src/acp_thread.rs

@@ -1,7 +1,12 @@
+mod connection;
+pub use connection::*;
+
 pub use acp::ToolCallId;
-use agent_servers::AgentServer;
-use agentic_coding_protocol::{self as acp, ToolCallLocation, UserMessageChunk};
-use anyhow::{Context as _, Result, anyhow};
+use agentic_coding_protocol::{
+    self as acp, AgentRequest, ProtocolVersion, ToolCallConfirmationOutcome, ToolCallLocation,
+    UserMessageChunk,
+};
+use anyhow::{Context as _, Result};
 use assistant_tool::ActionLog;
 use buffer_diff::BufferDiff;
 use editor::{Bias, MultiBuffer, PathKey};
@@ -97,7 +102,7 @@ pub struct AssistantMessage {
 }
 
 impl AssistantMessage {
-    fn to_markdown(&self, cx: &App) -> String {
+    pub fn to_markdown(&self, cx: &App) -> String {
         format!(
             "## Assistant\n\n{}\n\n",
             self.chunks
@@ -455,9 +460,8 @@ pub struct AcpThread {
     action_log: Entity<ActionLog>,
     shared_buffers: HashMap<Entity<Buffer>, BufferSnapshot>,
     send_task: Option<Task<()>>,
-    connection: Arc<acp::AgentConnection>,
+    connection: Arc<dyn AgentConnection>,
     child_status: Option<Task<Result<()>>>,
-    _io_task: Task<()>,
 }
 
 pub enum AcpThreadEvent {
@@ -476,7 +480,11 @@ pub enum ThreadStatus {
 
 #[derive(Debug, Clone)]
 pub enum LoadError {
-    Unsupported { current_version: SharedString },
+    Unsupported {
+        error_message: SharedString,
+        upgrade_message: SharedString,
+        upgrade_command: String,
+    },
     Exited(i32),
     Other(SharedString),
 }
@@ -484,13 +492,7 @@ pub enum LoadError {
 impl Display for LoadError {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
-            LoadError::Unsupported { current_version } => {
-                write!(
-                    f,
-                    "Your installed version of Gemini {} doesn't support the Agentic Coding Protocol (ACP).",
-                    current_version
-                )
-            }
+            LoadError::Unsupported { error_message, .. } => write!(f, "{}", error_message),
             LoadError::Exited(status) => write!(f, "Server exited with status {}", status),
             LoadError::Other(msg) => write!(f, "{}", msg),
         }
@@ -500,75 +502,38 @@ impl Display for LoadError {
 impl Error for LoadError {}
 
 impl AcpThread {
-    pub async fn spawn(
-        server: impl AgentServer + 'static,
-        root_dir: &Path,
+    pub fn new(
+        connection: impl AgentConnection + 'static,
+        title: SharedString,
+        child_status: Option<Task<Result<()>>>,
         project: Entity<Project>,
-        cx: &mut AsyncApp,
-    ) -> Result<Entity<Self>> {
-        let command = match server.command(&project, cx).await {
-            Ok(command) => command,
-            Err(e) => return Err(anyhow!(LoadError::Other(format!("{e}").into()))),
-        };
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let action_log = cx.new(|_| ActionLog::new(project.clone()));
 
-        let mut child = util::command::new_smol_command(&command.path)
-            .args(command.args.iter())
-            .current_dir(root_dir)
-            .stdin(std::process::Stdio::piped())
-            .stdout(std::process::Stdio::piped())
-            .stderr(std::process::Stdio::inherit())
-            .kill_on_drop(true)
-            .spawn()?;
+        Self {
+            action_log,
+            shared_buffers: Default::default(),
+            entries: Default::default(),
+            title,
+            project,
+            send_task: None,
+            connection: Arc::new(connection),
+            child_status,
+        }
+    }
 
-        let stdin = child.stdin.take().unwrap();
-        let stdout = child.stdout.take().unwrap();
-
-        cx.new(|cx| {
-            let foreground_executor = cx.foreground_executor().clone();
-
-            let (connection, io_fut) = acp::AgentConnection::connect_to_agent(
-                AcpClientDelegate::new(cx.entity().downgrade(), cx.to_async()),
-                stdin,
-                stdout,
-                move |fut| foreground_executor.spawn(fut).detach(),
-            );
-
-            let io_task = cx.background_spawn(async move {
-                io_fut.await.log_err();
-            });
-
-            let child_status = cx.background_spawn(async move {
-                match child.status().await {
-                    Err(e) => Err(anyhow!(e)),
-                    Ok(result) if result.success() => Ok(()),
-                    Ok(result) => {
-                        if let Some(version) = server.version(&command).await.log_err()
-                            && !version.supported
-                        {
-                            Err(anyhow!(LoadError::Unsupported {
-                                current_version: version.current_version
-                            }))
-                        } else {
-                            Err(anyhow!(LoadError::Exited(result.code().unwrap_or(-127))))
-                        }
-                    }
-                }
-            });
-
-            let action_log = cx.new(|_| ActionLog::new(project.clone()));
-
-            Self {
-                action_log,
-                shared_buffers: Default::default(),
-                entries: Default::default(),
-                title: "ACP Thread".into(),
-                project,
-                send_task: None,
-                connection: Arc::new(connection),
-                child_status: Some(child_status),
-                _io_task: io_task,
-            }
-        })
+    /// Send a request to the agent and wait for a response.
+    pub fn request<R: AgentRequest + 'static>(
+        &self,
+        params: R,
+    ) -> impl use<R> + Future<Output = Result<R::Response>> {
+        let params = params.into_any();
+        let result = self.connection.request_any(params);
+        async move {
+            let result = result.await?;
+            Ok(R::response_from_any(result)?)
+        }
     }
 
     pub fn action_log(&self) -> &Entity<ActionLog> {
@@ -579,45 +544,6 @@ impl AcpThread {
         &self.project
     }
 
-    #[cfg(test)]
-    pub fn fake(
-        stdin: async_pipe::PipeWriter,
-        stdout: async_pipe::PipeReader,
-        project: Entity<Project>,
-        cx: &mut Context<Self>,
-    ) -> Self {
-        let foreground_executor = cx.foreground_executor().clone();
-
-        let (connection, io_fut) = acp::AgentConnection::connect_to_agent(
-            AcpClientDelegate::new(cx.entity().downgrade(), cx.to_async()),
-            stdin,
-            stdout,
-            move |fut| {
-                foreground_executor.spawn(fut).detach();
-            },
-        );
-
-        let io_task = cx.background_spawn({
-            async move {
-                io_fut.await.log_err();
-            }
-        });
-
-        let action_log = cx.new(|_| ActionLog::new(project.clone()));
-
-        Self {
-            action_log,
-            shared_buffers: Default::default(),
-            entries: Default::default(),
-            title: "ACP Thread".into(),
-            project,
-            send_task: None,
-            connection: Arc::new(connection),
-            child_status: None,
-            _io_task: io_task,
-        }
-    }
-
     pub fn title(&self) -> SharedString {
         self.title.clone()
     }
@@ -711,7 +637,7 @@ impl AcpThread {
         }
     }
 
-    pub fn request_tool_call(
+    pub fn request_new_tool_call(
         &mut self,
         tool_call: acp::RequestToolCallConfirmationParams,
         cx: &mut Context<Self>,
@@ -731,6 +657,32 @@ impl AcpThread {
         ToolCallRequest { id, outcome: rx }
     }
 
+    pub fn request_tool_call_confirmation(
+        &mut self,
+        tool_call_id: ToolCallId,
+        confirmation: acp::ToolCallConfirmation,
+        cx: &mut Context<Self>,
+    ) -> Result<ToolCallRequest> {
+        let project = self.project.read(cx).languages().clone();
+        let Some((idx, call)) = self.tool_call_mut(tool_call_id) else {
+            anyhow::bail!("Tool call not found");
+        };
+
+        let (tx, rx) = oneshot::channel();
+
+        call.status = ToolCallStatus::WaitingForConfirmation {
+            confirmation: ToolCallConfirmation::from_acp(confirmation, project, cx),
+            respond_tx: tx,
+        };
+
+        cx.emit(AcpThreadEvent::EntryUpdated(idx));
+
+        Ok(ToolCallRequest {
+            id: tool_call_id,
+            outcome: rx,
+        })
+    }
+
     pub fn push_tool_call(
         &mut self,
         request: acp::PushToolCallParams,
@@ -818,8 +770,13 @@ impl AcpThread {
         let language_registry = self.project.read(cx).languages().clone();
         let (ix, call) = self.tool_call_mut(id).context("Entry not found")?;
 
-        call.content = new_content
-            .map(|new_content| ToolCallContent::from_acp(new_content, language_registry, cx));
+        if let Some(new_content) = new_content {
+            call.content = Some(ToolCallContent::from_acp(
+                new_content,
+                language_registry,
+                cx,
+            ));
+        }
 
         match &mut call.status {
             ToolCallStatus::Allowed { status } => {
@@ -912,19 +869,17 @@ impl AcpThread {
         false
     }
 
-    pub fn initialize(
-        &self,
-    ) -> impl use<> + Future<Output = Result<acp::InitializeResponse, acp::Error>> {
-        let connection = self.connection.clone();
-        async move { connection.initialize().await }
+    pub fn initialize(&self) -> impl use<> + Future<Output = Result<acp::InitializeResponse>> {
+        self.request(acp::InitializeParams {
+            protocol_version: ProtocolVersion::latest(),
+        })
     }
 
-    pub fn authenticate(&self) -> impl use<> + Future<Output = Result<(), acp::Error>> {
-        let connection = self.connection.clone();
-        async move { connection.request(acp::AuthenticateParams).await }
+    pub fn authenticate(&self) -> impl use<> + Future<Output = Result<()>> {
+        self.request(acp::AuthenticateParams)
     }
 
-    #[cfg(test)]
+    #[cfg(any(test, feature = "test-support"))]
     pub fn send_raw(
         &mut self,
         message: &str,
@@ -945,7 +900,6 @@ impl AcpThread {
         message: acp::SendUserMessageParams,
         cx: &mut Context<Self>,
     ) -> BoxFuture<'static, Result<(), acp::Error>> {
-        let agent = self.connection.clone();
         self.push_entry(
             AgentThreadEntry::UserMessage(UserMessage::from_acp(
                 &message,
@@ -959,11 +913,16 @@ impl AcpThread {
         let cancel = self.cancel(cx);
 
         self.send_task = Some(cx.spawn(async move |this, cx| {
-            cancel.await.log_err();
+            async {
+                cancel.await.log_err();
 
-            let result = agent.request(message).await;
-            tx.send(result).log_err();
-            this.update(cx, |this, _cx| this.send_task.take()).log_err();
+                let result = this.update(cx, |this, _| this.request(message))?.await;
+                tx.send(result).log_err();
+                this.update(cx, |this, _cx| this.send_task.take())?;
+                anyhow::Ok(())
+            }
+            .await
+            .log_err();
         }));
 
         async move {
@@ -976,12 +935,10 @@ impl AcpThread {
     }
 
     pub fn cancel(&mut self, cx: &mut Context<Self>) -> Task<Result<(), acp::Error>> {
-        let agent = self.connection.clone();
-
         if self.send_task.take().is_some() {
+            let request = self.request(acp::CancelSendMessageParams);
             cx.spawn(async move |this, cx| {
-                agent.request(acp::CancelSendMessageParams).await?;
-
+                request.await?;
                 this.update(cx, |this, _cx| {
                     for entry in this.entries.iter_mut() {
                         if let AgentThreadEntry::ToolCall(call) = entry {
@@ -1019,6 +976,7 @@ impl AcpThread {
     pub fn read_text_file(
         &self,
         request: acp::ReadTextFileParams,
+        reuse_shared_snapshot: bool,
         cx: &mut Context<Self>,
     ) -> Task<Result<String>> {
         let project = self.project.clone();
@@ -1032,28 +990,60 @@ impl AcpThread {
             });
             let buffer = load??.await?;
 
-            action_log.update(cx, |action_log, cx| {
-                action_log.buffer_read(buffer.clone(), cx);
-            })?;
-            project.update(cx, |project, cx| {
-                let position = buffer
-                    .read(cx)
-                    .snapshot()
-                    .anchor_before(Point::new(request.line.unwrap_or_default(), 0));
-                project.set_agent_location(
-                    Some(AgentLocation {
-                        buffer: buffer.downgrade(),
-                        position,
-                    }),
-                    cx,
-                );
-            })?;
-            let snapshot = buffer.update(cx, |buffer, _| buffer.snapshot())?;
+            let snapshot = if reuse_shared_snapshot {
+                this.read_with(cx, |this, _| {
+                    this.shared_buffers.get(&buffer.clone()).cloned()
+                })
+                .log_err()
+                .flatten()
+            } else {
+                None
+            };
+
+            let snapshot = if let Some(snapshot) = snapshot {
+                snapshot
+            } else {
+                action_log.update(cx, |action_log, cx| {
+                    action_log.buffer_read(buffer.clone(), cx);
+                })?;
+                project.update(cx, |project, cx| {
+                    let position = buffer
+                        .read(cx)
+                        .snapshot()
+                        .anchor_before(Point::new(request.line.unwrap_or_default(), 0));
+                    project.set_agent_location(
+                        Some(AgentLocation {
+                            buffer: buffer.downgrade(),
+                            position,
+                        }),
+                        cx,
+                    );
+                })?;
+
+                buffer.update(cx, |buffer, _| buffer.snapshot())?
+            };
+
             this.update(cx, |this, _| {
                 let text = snapshot.text();
                 this.shared_buffers.insert(buffer.clone(), snapshot);
-                text
-            })
+                if request.line.is_none() && request.limit.is_none() {
+                    return Ok(text);
+                }
+                let limit = request.limit.unwrap_or(u32::MAX) as usize;
+                let Some(line) = request.line else {
+                    return Ok(text.lines().take(limit).collect::<String>());
+                };
+
+                let count = text.lines().count();
+                if count < line as usize {
+                    anyhow::bail!("There are only {} lines", count);
+                }
+                Ok(text
+                    .lines()
+                    .skip(line as usize + 1)
+                    .take(limit)
+                    .collect::<String>())
+            })?
         })
     }
 
@@ -1134,16 +1124,49 @@ impl AcpThread {
     }
 }
 
-struct AcpClientDelegate {
+#[derive(Clone)]
+pub struct AcpClientDelegate {
     thread: WeakEntity<AcpThread>,
     cx: AsyncApp,
     // sent_buffer_versions: HashMap<Entity<Buffer>, HashMap<u64, BufferSnapshot>>,
 }
 
 impl AcpClientDelegate {
-    fn new(thread: WeakEntity<AcpThread>, cx: AsyncApp) -> Self {
+    pub fn new(thread: WeakEntity<AcpThread>, cx: AsyncApp) -> Self {
         Self { thread, cx }
     }
+
+    pub async fn request_existing_tool_call_confirmation(
+        &self,
+        tool_call_id: ToolCallId,
+        confirmation: acp::ToolCallConfirmation,
+    ) -> Result<ToolCallConfirmationOutcome> {
+        let cx = &mut self.cx.clone();
+        let ToolCallRequest { outcome, .. } = cx
+            .update(|cx| {
+                self.thread.update(cx, |thread, cx| {
+                    thread.request_tool_call_confirmation(tool_call_id, confirmation, cx)
+                })
+            })?
+            .context("Failed to update thread")??;
+
+        Ok(outcome.await?)
+    }
+
+    pub async fn read_text_file_reusing_snapshot(
+        &self,
+        request: acp::ReadTextFileParams,
+    ) -> Result<acp::ReadTextFileResponse, acp::Error> {
+        let content = self
+            .cx
+            .update(|cx| {
+                self.thread
+                    .update(cx, |thread, cx| thread.read_text_file(request, true, cx))
+            })?
+            .context("Failed to update thread")?
+            .await?;
+        Ok(acp::ReadTextFileResponse { content })
+    }
 }
 
 impl acp::Client for AcpClientDelegate {
@@ -1172,7 +1195,7 @@ impl acp::Client for AcpClientDelegate {
         let ToolCallRequest { id, outcome } = cx
             .update(|cx| {
                 self.thread
-                    .update(cx, |thread, cx| thread.request_tool_call(request, cx))
+                    .update(cx, |thread, cx| thread.request_new_tool_call(request, cx))
             })?
             .context("Failed to update thread")?;
 
@@ -1218,7 +1241,7 @@ impl acp::Client for AcpClientDelegate {
             .cx
             .update(|cx| {
                 self.thread
-                    .update(cx, |thread, cx| thread.read_text_file(request, cx))
+                    .update(cx, |thread, cx| thread.read_text_file(request, false, cx))
             })?
             .context("Failed to update thread")?
             .await?;
@@ -1260,7 +1283,7 @@ pub struct ToolCallRequest {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use agent_servers::{AgentServerCommand, AgentServerVersion};
+    use anyhow::anyhow;
     use async_pipe::{PipeReader, PipeWriter};
     use futures::{channel::mpsc, future::LocalBoxFuture, select};
     use gpui::{AsyncApp, TestAppContext};
@@ -1269,7 +1292,7 @@ mod tests {
     use serde_json::json;
     use settings::SettingsStore;
     use smol::{future::BoxedLocal, stream::StreamExt as _};
-    use std::{cell::RefCell, env, path::Path, rc::Rc, time::Duration};
+    use std::{cell::RefCell, rc::Rc, time::Duration};
     use util::path;
 
     fn init_test(cx: &mut TestAppContext) {
@@ -1515,265 +1538,6 @@ mod tests {
         });
     }
 
-    #[gpui::test]
-    #[cfg_attr(not(feature = "gemini"), ignore)]
-    async fn test_gemini_basic(cx: &mut TestAppContext) {
-        init_test(cx);
-
-        cx.executor().allow_parking();
-
-        let fs = FakeFs::new(cx.executor());
-        let project = Project::test(fs, [], cx).await;
-        let thread = gemini_acp_thread(project.clone(), "/private/tmp", cx).await;
-        thread
-            .update(cx, |thread, cx| thread.send_raw("Hello from Zed!", cx))
-            .await
-            .unwrap();
-
-        thread.read_with(cx, |thread, _| {
-            assert_eq!(thread.entries.len(), 2);
-            assert!(matches!(
-                thread.entries[0],
-                AgentThreadEntry::UserMessage(_)
-            ));
-            assert!(matches!(
-                thread.entries[1],
-                AgentThreadEntry::AssistantMessage(_)
-            ));
-        });
-    }
-
-    #[gpui::test]
-    #[cfg_attr(not(feature = "gemini"), ignore)]
-    async fn test_gemini_path_mentions(cx: &mut TestAppContext) {
-        init_test(cx);
-
-        cx.executor().allow_parking();
-        let tempdir = tempfile::tempdir().unwrap();
-        std::fs::write(
-            tempdir.path().join("foo.rs"),
-            indoc! {"
-                fn main() {
-                    println!(\"Hello, world!\");
-                }
-            "},
-        )
-        .expect("failed to write file");
-        let project = Project::example([tempdir.path()], &mut cx.to_async()).await;
-        let thread = gemini_acp_thread(project.clone(), tempdir.path(), cx).await;
-        thread
-            .update(cx, |thread, cx| {
-                thread.send(
-                    acp::SendUserMessageParams {
-                        chunks: vec![
-                            acp::UserMessageChunk::Text {
-                                text: "Read the file ".into(),
-                            },
-                            acp::UserMessageChunk::Path {
-                                path: Path::new("foo.rs").into(),
-                            },
-                            acp::UserMessageChunk::Text {
-                                text: " and tell me what the content of the println! is".into(),
-                            },
-                        ],
-                    },
-                    cx,
-                )
-            })
-            .await
-            .unwrap();
-
-        thread.read_with(cx, |thread, cx| {
-            assert_eq!(thread.entries.len(), 3);
-            assert!(matches!(
-                thread.entries[0],
-                AgentThreadEntry::UserMessage(_)
-            ));
-            assert!(matches!(thread.entries[1], AgentThreadEntry::ToolCall(_)));
-            let AgentThreadEntry::AssistantMessage(assistant_message) = &thread.entries[2] else {
-                panic!("Expected AssistantMessage")
-            };
-            assert!(
-                assistant_message.to_markdown(cx).contains("Hello, world!"),
-                "unexpected assistant message: {:?}",
-                assistant_message.to_markdown(cx)
-            );
-        });
-    }
-
-    #[gpui::test]
-    #[cfg_attr(not(feature = "gemini"), ignore)]
-    async fn test_gemini_tool_call(cx: &mut TestAppContext) {
-        init_test(cx);
-
-        cx.executor().allow_parking();
-
-        let fs = FakeFs::new(cx.executor());
-        fs.insert_tree(
-            path!("/private/tmp"),
-            json!({"foo": "Lorem ipsum dolor", "bar": "bar", "baz": "baz"}),
-        )
-        .await;
-        let project = Project::test(fs, [path!("/private/tmp").as_ref()], cx).await;
-        let thread = gemini_acp_thread(project.clone(), "/private/tmp", cx).await;
-        thread
-            .update(cx, |thread, cx| {
-                thread.send_raw(
-                    "Read the '/private/tmp/foo' file and tell me what you see.",
-                    cx,
-                )
-            })
-            .await
-            .unwrap();
-        thread.read_with(cx, |thread, _cx| {
-            assert!(matches!(
-                &thread.entries()[2],
-                AgentThreadEntry::ToolCall(ToolCall {
-                    status: ToolCallStatus::Allowed { .. },
-                    ..
-                })
-            ));
-
-            assert!(matches!(
-                thread.entries[3],
-                AgentThreadEntry::AssistantMessage(_)
-            ));
-        });
-    }
-
-    #[gpui::test]
-    #[cfg_attr(not(feature = "gemini"), ignore)]
-    async fn test_gemini_tool_call_with_confirmation(cx: &mut TestAppContext) {
-        init_test(cx);
-
-        cx.executor().allow_parking();
-
-        let fs = FakeFs::new(cx.executor());
-        let project = Project::test(fs, [path!("/private/tmp").as_ref()], cx).await;
-        let thread = gemini_acp_thread(project.clone(), "/private/tmp", cx).await;
-        let full_turn = thread.update(cx, |thread, cx| {
-            thread.send_raw(r#"Run `echo "Hello, world!"`"#, cx)
-        });
-
-        run_until_first_tool_call(&thread, cx).await;
-
-        let tool_call_id = thread.read_with(cx, |thread, _cx| {
-            let AgentThreadEntry::ToolCall(ToolCall {
-                id,
-                status:
-                    ToolCallStatus::WaitingForConfirmation {
-                        confirmation: ToolCallConfirmation::Execute { root_command, .. },
-                        ..
-                    },
-                ..
-            }) = &thread.entries()[2]
-            else {
-                panic!();
-            };
-
-            assert_eq!(root_command, "echo");
-
-            *id
-        });
-
-        thread.update(cx, |thread, cx| {
-            thread.authorize_tool_call(tool_call_id, acp::ToolCallConfirmationOutcome::Allow, cx);
-
-            assert!(matches!(
-                &thread.entries()[2],
-                AgentThreadEntry::ToolCall(ToolCall {
-                    status: ToolCallStatus::Allowed { .. },
-                    ..
-                })
-            ));
-        });
-
-        full_turn.await.unwrap();
-
-        thread.read_with(cx, |thread, cx| {
-            let AgentThreadEntry::ToolCall(ToolCall {
-                content: Some(ToolCallContent::Markdown { markdown }),
-                status: ToolCallStatus::Allowed { .. },
-                ..
-            }) = &thread.entries()[2]
-            else {
-                panic!();
-            };
-
-            markdown.read_with(cx, |md, _cx| {
-                assert!(
-                    md.source().contains("Hello, world!"),
-                    r#"Expected '{}' to contain "Hello, world!""#,
-                    md.source()
-                );
-            });
-        });
-    }
-
-    #[gpui::test]
-    #[cfg_attr(not(feature = "gemini"), ignore)]
-    async fn test_gemini_cancel(cx: &mut TestAppContext) {
-        init_test(cx);
-
-        cx.executor().allow_parking();
-
-        let fs = FakeFs::new(cx.executor());
-        let project = Project::test(fs, [path!("/private/tmp").as_ref()], cx).await;
-        let thread = gemini_acp_thread(project.clone(), "/private/tmp", cx).await;
-        let full_turn = thread.update(cx, |thread, cx| {
-            thread.send_raw(r#"Run `echo "Hello, world!"`"#, cx)
-        });
-
-        let first_tool_call_ix = run_until_first_tool_call(&thread, cx).await;
-
-        thread.read_with(cx, |thread, _cx| {
-            let AgentThreadEntry::ToolCall(ToolCall {
-                id,
-                status:
-                    ToolCallStatus::WaitingForConfirmation {
-                        confirmation: ToolCallConfirmation::Execute { root_command, .. },
-                        ..
-                    },
-                ..
-            }) = &thread.entries()[first_tool_call_ix]
-            else {
-                panic!("{:?}", thread.entries()[1]);
-            };
-
-            assert_eq!(root_command, "echo");
-
-            *id
-        });
-
-        thread
-            .update(cx, |thread, cx| thread.cancel(cx))
-            .await
-            .unwrap();
-        full_turn.await.unwrap();
-        thread.read_with(cx, |thread, _| {
-            let AgentThreadEntry::ToolCall(ToolCall {
-                status: ToolCallStatus::Canceled,
-                ..
-            }) = &thread.entries()[first_tool_call_ix]
-            else {
-                panic!();
-            };
-        });
-
-        thread
-            .update(cx, |thread, cx| {
-                thread.send_raw(r#"Stop running and say goodbye to me."#, cx)
-            })
-            .await
-            .unwrap();
-        thread.read_with(cx, |thread, _| {
-            assert!(matches!(
-                &thread.entries().last().unwrap(),
-                AgentThreadEntry::AssistantMessage(..),
-            ))
-        });
-    }
-
     async fn run_until_first_tool_call(
         thread: &Entity<AcpThread>,
         cx: &mut TestAppContext,
@@ -1801,66 +1565,39 @@ mod tests {
         }
     }
 
-    pub async fn gemini_acp_thread(
-        project: Entity<Project>,
-        current_dir: impl AsRef<Path>,
-        cx: &mut TestAppContext,
-    ) -> Entity<AcpThread> {
-        struct DevGemini;
-
-        impl agent_servers::AgentServer for DevGemini {
-            async fn command(
-                &self,
-                _project: &Entity<Project>,
-                _cx: &mut AsyncApp,
-            ) -> Result<agent_servers::AgentServerCommand> {
-                let cli_path = Path::new(env!("CARGO_MANIFEST_DIR"))
-                    .join("../../../gemini-cli/packages/cli")
-                    .to_string_lossy()
-                    .to_string();
-
-                Ok(AgentServerCommand {
-                    path: "node".into(),
-                    args: vec![cli_path, "--experimental-acp".into()],
-                    env: None,
-                })
-            }
-
-            async fn version(
-                &self,
-                _command: &agent_servers::AgentServerCommand,
-            ) -> Result<AgentServerVersion> {
-                Ok(AgentServerVersion {
-                    current_version: "0.1.0".into(),
-                    supported: true,
-                })
-            }
-        }
-
-        let thread = AcpThread::spawn(DevGemini, current_dir.as_ref(), project, &mut cx.to_async())
-            .await
-            .unwrap();
-
-        thread
-            .update(cx, |thread, _| thread.initialize())
-            .await
-            .unwrap();
-        thread
-    }
-
     pub fn fake_acp_thread(
         project: Entity<Project>,
         cx: &mut TestAppContext,
     ) -> (Entity<AcpThread>, Entity<FakeAcpServer>) {
         let (stdin_tx, stdin_rx) = async_pipe::pipe();
         let (stdout_tx, stdout_rx) = async_pipe::pipe();
-        let thread = cx.update(|cx| cx.new(|cx| AcpThread::fake(stdin_tx, stdout_rx, project, cx)));
+
+        let thread = cx.new(|cx| {
+            let foreground_executor = cx.foreground_executor().clone();
+            let (connection, io_fut) = acp::AgentConnection::connect_to_agent(
+                AcpClientDelegate::new(cx.entity().downgrade(), cx.to_async()),
+                stdin_tx,
+                stdout_rx,
+                move |fut| {
+                    foreground_executor.spawn(fut).detach();
+                },
+            );
+
+            let io_task = cx.background_spawn({
+                async move {
+                    io_fut.await.log_err();
+                    Ok(())
+                }
+            });
+            AcpThread::new(connection, "Test".into(), Some(io_task), project, cx)
+        });
         let agent = cx.update(|cx| cx.new(|cx| FakeAcpServer::new(stdin_rx, stdout_tx, cx)));
         (thread, agent)
     }
 
     pub struct FakeAcpServer {
         connection: acp::ClientConnection,
+
         _io_task: Task<()>,
         on_user_message: Option<
             Rc<

crates/acp_thread/src/connection.rs

@@ -0,0 +1,20 @@
+use agentic_coding_protocol as acp;
+use anyhow::Result;
+use futures::future::{FutureExt as _, LocalBoxFuture};
+
+pub trait AgentConnection {
+    fn request_any(
+        &self,
+        params: acp::AnyAgentRequest,
+    ) -> LocalBoxFuture<'static, Result<acp::AnyAgentResult>>;
+}
+
+impl AgentConnection for acp::AgentConnection {
+    fn request_any(
+        &self,
+        params: acp::AnyAgentRequest,
+    ) -> LocalBoxFuture<'static, Result<acp::AnyAgentResult>> {
+        let task = self.request_any(params);
+        async move { Ok(task.await?) }.boxed_local()
+    }
+}

crates/agent/src/context_server_tool.rs

@@ -38,7 +38,7 @@ impl Tool for ContextServerTool {
     }
 
     fn icon(&self) -> IconName {
-        IconName::Cog
+        IconName::ToolHammer
     }
 
     fn source(&self) -> ToolSource {

crates/agent/src/thread.rs

@@ -396,6 +396,7 @@ pub struct Thread {
     remaining_turns: u32,
     configured_model: Option<ConfiguredModel>,
     profile: AgentProfile,
+    last_error_context: Option<(Arc<dyn LanguageModel>, CompletionIntent)>,
 }
 
 #[derive(Clone, Debug)]
@@ -489,10 +490,11 @@ impl Thread {
             retry_state: None,
             message_feedback: HashMap::default(),
             last_auto_capture_at: None,
+            last_error_context: None,
             last_received_chunk_at: None,
             request_callback: None,
             remaining_turns: u32::MAX,
-            configured_model,
+            configured_model: configured_model.clone(),
             profile: AgentProfile::new(profile_id, tools),
         }
     }
@@ -613,6 +615,7 @@ impl Thread {
             feedback: None,
             message_feedback: HashMap::default(),
             last_auto_capture_at: None,
+            last_error_context: None,
             last_received_chunk_at: None,
             request_callback: None,
             remaining_turns: u32::MAX,
@@ -1264,9 +1267,58 @@ impl Thread {
 
         self.flush_notifications(model.clone(), intent, cx);
 
-        let request = self.to_completion_request(model.clone(), intent, cx);
+        let _checkpoint = self.finalize_pending_checkpoint(cx);
+        self.stream_completion(
+            self.to_completion_request(model.clone(), intent, cx),
+            model,
+            intent,
+            window,
+            cx,
+        );
+    }
 
-        self.stream_completion(request, model, intent, window, cx);
+    pub fn retry_last_completion(
+        &mut self,
+        window: Option<AnyWindowHandle>,
+        cx: &mut Context<Self>,
+    ) {
+        // Clear any existing error state
+        self.retry_state = None;
+
+        // Use the last error context if available, otherwise fall back to configured model
+        let (model, intent) = if let Some((model, intent)) = self.last_error_context.take() {
+            (model, intent)
+        } else if let Some(configured_model) = self.configured_model.as_ref() {
+            let model = configured_model.model.clone();
+            let intent = if self.has_pending_tool_uses() {
+                CompletionIntent::ToolResults
+            } else {
+                CompletionIntent::UserPrompt
+            };
+            (model, intent)
+        } else if let Some(configured_model) = self.get_or_init_configured_model(cx) {
+            let model = configured_model.model.clone();
+            let intent = if self.has_pending_tool_uses() {
+                CompletionIntent::ToolResults
+            } else {
+                CompletionIntent::UserPrompt
+            };
+            (model, intent)
+        } else {
+            return;
+        };
+
+        self.send_to_model(model, intent, window, cx);
+    }
+
+    pub fn enable_burn_mode_and_retry(
+        &mut self,
+        window: Option<AnyWindowHandle>,
+        cx: &mut Context<Self>,
+    ) {
+        self.completion_mode = CompletionMode::Burn;
+        cx.emit(ThreadEvent::ProfileChanged);
+        self.retry_last_completion(window, cx);
     }
 
     pub fn used_tools_since_last_user_message(&self) -> bool {
@@ -2146,6 +2198,35 @@ impl Thread {
                     max_attempts: MAX_RETRY_ATTEMPTS,
                 })
             }
+            UpstreamProviderError {
+                status,
+                retry_after,
+                ..
+            } => match *status {
+                StatusCode::TOO_MANY_REQUESTS | StatusCode::SERVICE_UNAVAILABLE => {
+                    Some(RetryStrategy::Fixed {
+                        delay: retry_after.unwrap_or(BASE_RETRY_DELAY),
+                        max_attempts: MAX_RETRY_ATTEMPTS,
+                    })
+                }
+                StatusCode::INTERNAL_SERVER_ERROR => Some(RetryStrategy::Fixed {
+                    delay: retry_after.unwrap_or(BASE_RETRY_DELAY),
+                    // Internal Server Error could be anything, so only retry once.
+                    max_attempts: 1,
+                }),
+                status => {
+                    // There is no StatusCode variant for the unofficial HTTP 529 ("The service is overloaded"),
+                    // but we frequently get them in practice. See https://http.dev/529
+                    if status.as_u16() == 529 {
+                        Some(RetryStrategy::Fixed {
+                            delay: retry_after.unwrap_or(BASE_RETRY_DELAY),
+                            max_attempts: MAX_RETRY_ATTEMPTS,
+                        })
+                    } else {
+                        None
+                    }
+                }
+            },
             ApiInternalServerError { .. } => Some(RetryStrategy::Fixed {
                 delay: BASE_RETRY_DELAY,
                 max_attempts: 1,
@@ -2193,6 +2274,23 @@ impl Thread {
         window: Option<AnyWindowHandle>,
         cx: &mut Context<Self>,
     ) -> bool {
+        // Store context for the Retry button
+        self.last_error_context = Some((model.clone(), intent));
+
+        // Only auto-retry if Burn Mode is enabled
+        if self.completion_mode != CompletionMode::Burn {
+            // Show error with retry options
+            cx.emit(ThreadEvent::ShowError(ThreadError::RetryableError {
+                message: format!(
+                    "{}\n\nTo automatically retry when similar errors happen, enable Burn Mode.",
+                    error
+                )
+                .into(),
+                can_enable_burn_mode: true,
+            }));
+            return false;
+        }
+
         let Some(strategy) = strategy.or_else(|| Self::get_retry_strategy(error)) else {
             return false;
         };
@@ -2273,6 +2371,13 @@ impl Thread {
             // Stop generating since we're giving up on retrying.
             self.pending_completions.clear();
 
+            // Show error alongside a Retry button, but no
+            // Enable Burn Mode button (since it's already enabled)
+            cx.emit(ThreadEvent::ShowError(ThreadError::RetryableError {
+                message: format!("Failed after retrying: {}", error).into(),
+                can_enable_burn_mode: false,
+            }));
+
             false
         }
     }
@@ -3183,6 +3288,11 @@ pub enum ThreadError {
         header: SharedString,
         message: SharedString,
     },
+    #[error("Retryable error: {message}")]
+    RetryableError {
+        message: SharedString,
+        can_enable_burn_mode: bool,
+    },
 }
 
 #[derive(Debug, Clone)]
@@ -3583,6 +3693,7 @@ fn main() {{
     }
 
     #[gpui::test]
+    #[ignore] // turn this test on when project_notifications tool is re-enabled
     async fn test_stale_buffer_notification(cx: &mut TestAppContext) {
         init_test_settings(cx);
 
@@ -4137,6 +4248,11 @@ fn main() {{
         let project = create_test_project(cx, json!({})).await;
         let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await;
 
+        // Enable Burn Mode to allow retries
+        thread.update(cx, |thread, _| {
+            thread.set_completion_mode(CompletionMode::Burn);
+        });
+
         // Create model that returns overloaded error
         let model = Arc::new(ErrorInjector::new(TestError::Overloaded));
 
@@ -4210,6 +4326,11 @@ fn main() {{
         let project = create_test_project(cx, json!({})).await;
         let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await;
 
+        // Enable Burn Mode to allow retries
+        thread.update(cx, |thread, _| {
+            thread.set_completion_mode(CompletionMode::Burn);
+        });
+
         // Create model that returns internal server error
         let model = Arc::new(ErrorInjector::new(TestError::InternalServerError));
 
@@ -4286,6 +4407,11 @@ fn main() {{
         let project = create_test_project(cx, json!({})).await;
         let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await;
 
+        // Enable Burn Mode to allow retries
+        thread.update(cx, |thread, _| {
+            thread.set_completion_mode(CompletionMode::Burn);
+        });
+
         // Create model that returns internal server error
         let model = Arc::new(ErrorInjector::new(TestError::InternalServerError));
 
@@ -4393,6 +4519,11 @@ fn main() {{
         let project = create_test_project(cx, json!({})).await;
         let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await;
 
+        // Enable Burn Mode to allow retries
+        thread.update(cx, |thread, _| {
+            thread.set_completion_mode(CompletionMode::Burn);
+        });
+
         // Create model that returns overloaded error
         let model = Arc::new(ErrorInjector::new(TestError::Overloaded));
 
@@ -4479,6 +4610,11 @@ fn main() {{
         let project = create_test_project(cx, json!({})).await;
         let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await;
 
+        // Enable Burn Mode to allow retries
+        thread.update(cx, |thread, _| {
+            thread.set_completion_mode(CompletionMode::Burn);
+        });
+
         // We'll use a wrapper to switch behavior after first failure
         struct RetryTestModel {
             inner: Arc<FakeLanguageModel>,
@@ -4647,6 +4783,11 @@ fn main() {{
         let project = create_test_project(cx, json!({})).await;
         let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await;
 
+        // Enable Burn Mode to allow retries
+        thread.update(cx, |thread, _| {
+            thread.set_completion_mode(CompletionMode::Burn);
+        });
+
         // Create a model that fails once then succeeds
         struct FailOnceModel {
             inner: Arc<FakeLanguageModel>,
@@ -4808,6 +4949,11 @@ fn main() {{
         let project = create_test_project(cx, json!({})).await;
         let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await;
 
+        // Enable Burn Mode to allow retries
+        thread.update(cx, |thread, _| {
+            thread.set_completion_mode(CompletionMode::Burn);
+        });
+
         // Create a model that returns rate limit error with retry_after
         struct RateLimitModel {
             inner: Arc<FakeLanguageModel>,
@@ -5081,6 +5227,79 @@ fn main() {{
         );
     }
 
+    #[gpui::test]
+    async fn test_no_retry_without_burn_mode(cx: &mut TestAppContext) {
+        init_test_settings(cx);
+
+        let project = create_test_project(cx, json!({})).await;
+        let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await;
+
+        // Ensure we're in Normal mode (not Burn mode)
+        thread.update(cx, |thread, _| {
+            thread.set_completion_mode(CompletionMode::Normal);
+        });
+
+        // Track error events
+        let error_events = Arc::new(Mutex::new(Vec::new()));
+        let error_events_clone = error_events.clone();
+
+        let _subscription = thread.update(cx, |_, cx| {
+            cx.subscribe(&thread, move |_, _, event: &ThreadEvent, _| {
+                if let ThreadEvent::ShowError(error) = event {
+                    error_events_clone.lock().push(error.clone());
+                }
+            })
+        });
+
+        // Create model that returns overloaded error
+        let model = Arc::new(ErrorInjector::new(TestError::Overloaded));
+
+        // Insert a user message
+        thread.update(cx, |thread, cx| {
+            thread.insert_user_message("Hello!", ContextLoadResult::default(), None, vec![], cx);
+        });
+
+        // Start completion
+        thread.update(cx, |thread, cx| {
+            thread.send_to_model(model.clone(), CompletionIntent::UserPrompt, None, cx);
+        });
+
+        cx.run_until_parked();
+
+        // Verify no retry state was created
+        thread.read_with(cx, |thread, _| {
+            assert!(
+                thread.retry_state.is_none(),
+                "Should not have retry state in Normal mode"
+            );
+        });
+
+        // Check that a retryable error was reported
+        let errors = error_events.lock();
+        assert!(!errors.is_empty(), "Should have received an error event");
+
+        if let ThreadError::RetryableError {
+            message: _,
+            can_enable_burn_mode,
+        } = &errors[0]
+        {
+            assert!(
+                *can_enable_burn_mode,
+                "Error should indicate burn mode can be enabled"
+            );
+        } else {
+            panic!("Expected RetryableError, got {:?}", errors[0]);
+        }
+
+        // Verify the thread is no longer generating
+        thread.read_with(cx, |thread, _| {
+            assert!(
+                !thread.is_generating(),
+                "Should not be generating after error without retry"
+            );
+        });
+    }
+
     #[gpui::test]
     async fn test_retry_cancelled_on_stop(cx: &mut TestAppContext) {
         init_test_settings(cx);
@@ -5088,6 +5307,11 @@ fn main() {{
         let project = create_test_project(cx, json!({})).await;
         let (_, _, thread, _, _base_model) = setup_test_environment(cx, project.clone()).await;
 
+        // Enable Burn Mode to allow retries
+        thread.update(cx, |thread, _| {
+            thread.set_completion_mode(CompletionMode::Burn);
+        });
+
         // Create model that returns overloaded error
         let model = Arc::new(ErrorInjector::new(TestError::Overloaded));
 

crates/agent_servers/Cargo.toml

@@ -5,6 +5,10 @@ edition.workspace = true
 publish.workspace = true
 license = "GPL-3.0-or-later"
 
+[features]
+test-support = ["acp_thread/test-support", "gpui/test-support", "project/test-support"]
+e2e = []
+
 [lints]
 workspace = true
 
@@ -13,15 +17,33 @@ path = "src/agent_servers.rs"
 doctest = false
 
 [dependencies]
+acp_thread.workspace = true
+agentic-coding-protocol.workspace = true
 anyhow.workspace = true
 collections.workspace = true
+context_server.workspace = true
 futures.workspace = true
 gpui.workspace = true
+itertools.workspace = true
+log.workspace = true
 paths.workspace = true
 project.workspace = true
 schemars.workspace = true
 serde.workspace = true
+serde_json.workspace = true
 settings.workspace = true
+smol.workspace = true
+strum.workspace = true
+tempfile.workspace = true
+ui.workspace = true
 util.workspace = true
+watch.workspace = true
 which.workspace = true
 workspace-hack.workspace = true
+
+[dev-dependencies]
+env_logger.workspace = true
+language.workspace = true
+indoc.workspace = true
+acp_thread = { workspace = true, features = ["test-support"] }
+gpui = { workspace = true, features = ["test-support"] }

crates/agent_servers/src/agent_servers.rs

@@ -1,30 +1,80 @@
+mod claude;
+mod gemini;
+mod settings;
+mod stdio_agent_server;
+
+#[cfg(test)]
+mod e2e_tests;
+
+pub use claude::*;
+pub use gemini::*;
+pub use settings::*;
+pub use stdio_agent_server::*;
+
+use acp_thread::AcpThread;
+use anyhow::Result;
+use collections::HashMap;
+use gpui::{App, AsyncApp, Entity, SharedString, Task};
+use project::Project;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
 use std::{
     path::{Path, PathBuf},
     sync::Arc,
 };
-
-use anyhow::{Context as _, Result};
-use collections::HashMap;
-use gpui::{App, AsyncApp, Entity, SharedString};
-use project::Project;
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources, SettingsStore};
-use util::{ResultExt, paths};
+use util::ResultExt as _;
 
 pub fn init(cx: &mut App) {
-    AllAgentServersSettings::register(cx);
+    settings::init(cx);
 }
 
-#[derive(Default, Deserialize, Serialize, Clone, JsonSchema, Debug)]
-pub struct AllAgentServersSettings {
-    gemini: Option<AgentServerSettings>,
+pub trait AgentServer: Send {
+    fn logo(&self) -> ui::IconName;
+    fn name(&self) -> &'static str;
+    fn empty_state_headline(&self) -> &'static str;
+    fn empty_state_message(&self) -> &'static str;
+    fn supports_always_allow(&self) -> bool;
+
+    fn new_thread(
+        &self,
+        root_dir: &Path,
+        project: &Entity<Project>,
+        cx: &mut App,
+    ) -> Task<Result<Entity<AcpThread>>>;
 }
 
-#[derive(Deserialize, Serialize, Clone, JsonSchema, Debug)]
-pub struct AgentServerSettings {
-    #[serde(flatten)]
-    command: AgentServerCommand,
+impl std::fmt::Debug for AgentServerCommand {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let filtered_env = self.env.as_ref().map(|env| {
+            env.iter()
+                .map(|(k, v)| {
+                    (
+                        k,
+                        if util::redact::should_redact(k) {
+                            "[REDACTED]"
+                        } else {
+                            v
+                        },
+                    )
+                })
+                .collect::<Vec<_>>()
+        });
+
+        f.debug_struct("AgentServerCommand")
+            .field("path", &self.path)
+            .field("args", &self.args)
+            .field("env", &filtered_env)
+            .finish()
+    }
+}
+
+pub enum AgentServerVersion {
+    Supported,
+    Unsupported {
+        error_message: SharedString,
+        upgrade_message: SharedString,
+        upgrade_command: String,
+    },
 }
 
 #[derive(Deserialize, Serialize, Clone, PartialEq, Eq, JsonSchema)]
@@ -36,105 +86,34 @@ pub struct AgentServerCommand {
     pub env: Option<HashMap<String, String>>,
 }
 
-pub struct Gemini;
-
-pub struct AgentServerVersion {
-    pub current_version: SharedString,
-    pub supported: bool,
-}
-
-pub trait AgentServer: Send {
-    fn command(
-        &self,
+impl AgentServerCommand {
+    pub(crate) async fn resolve(
+        path_bin_name: &'static str,
+        extra_args: &[&'static str],
+        settings: Option<AgentServerSettings>,
         project: &Entity<Project>,
         cx: &mut AsyncApp,
-    ) -> impl Future<Output = Result<AgentServerCommand>>;
-
-    fn version(
-        &self,
-        command: &AgentServerCommand,
-    ) -> impl Future<Output = Result<AgentServerVersion>> + Send;
-}
-
-const GEMINI_ACP_ARG: &str = "--experimental-acp";
-
-impl AgentServer for Gemini {
-    async fn command(
-        &self,
-        project: &Entity<Project>,
-        cx: &mut AsyncApp,
-    ) -> Result<AgentServerCommand> {
-        let custom_command = cx.read_global(|settings: &SettingsStore, _| {
-            let settings = settings.get::<AllAgentServersSettings>(None);
-            settings
-                .gemini
-                .as_ref()
-                .map(|gemini_settings| AgentServerCommand {
-                    path: gemini_settings.command.path.clone(),
-                    args: gemini_settings
-                        .command
-                        .args
-                        .iter()
-                        .cloned()
-                        .chain(std::iter::once(GEMINI_ACP_ARG.into()))
-                        .collect(),
-                    env: gemini_settings.command.env.clone(),
-                })
-        })?;
-
-        if let Some(custom_command) = custom_command {
-            return Ok(custom_command);
-        }
-
-        if let Some(path) = find_bin_in_path("gemini", project, cx).await {
-            return Ok(AgentServerCommand {
-                path,
-                args: vec![GEMINI_ACP_ARG.into()],
-                env: None,
+    ) -> Option<Self> {
+        if let Some(agent_settings) = settings {
+            return Some(Self {
+                path: agent_settings.command.path,
+                args: agent_settings
+                    .command
+                    .args
+                    .into_iter()
+                    .chain(extra_args.iter().map(|arg| arg.to_string()))
+                    .collect(),
+                env: agent_settings.command.env,
             });
+        } else {
+            find_bin_in_path(path_bin_name, project, cx)
+                .await
+                .map(|path| Self {
+                    path,
+                    args: extra_args.iter().map(|arg| arg.to_string()).collect(),
+                    env: None,
+                })
         }
-
-        let (fs, node_runtime) = project.update(cx, |project, _| {
-            (project.fs().clone(), project.node_runtime().cloned())
-        })?;
-        let node_runtime = node_runtime.context("gemini not found on path")?;
-
-        let directory = ::paths::agent_servers_dir().join("gemini");
-        fs.create_dir(&directory).await?;
-        node_runtime
-            .npm_install_packages(&directory, &[("@google/gemini-cli", "latest")])
-            .await?;
-        let path = directory.join("node_modules/.bin/gemini");
-
-        Ok(AgentServerCommand {
-            path,
-            args: vec![GEMINI_ACP_ARG.into()],
-            env: None,
-        })
-    }
-
-    async fn version(&self, command: &AgentServerCommand) -> Result<AgentServerVersion> {
-        let version_fut = util::command::new_smol_command(&command.path)
-            .args(command.args.iter())
-            .arg("--version")
-            .kill_on_drop(true)
-            .output();
-
-        let help_fut = util::command::new_smol_command(&command.path)
-            .args(command.args.iter())
-            .arg("--help")
-            .kill_on_drop(true)
-            .output();
-
-        let (version_output, help_output) = futures::future::join(version_fut, help_fut).await;
-
-        let current_version = String::from_utf8(version_output?.stdout)?.into();
-        let supported = String::from_utf8(help_output?.stdout)?.contains(GEMINI_ACP_ARG);
-
-        Ok(AgentServerVersion {
-            current_version,
-            supported,
-        })
     }
 }
 
@@ -184,48 +163,3 @@ async fn find_bin_in_path(
         })
         .await
 }
-
-impl std::fmt::Debug for AgentServerCommand {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let filtered_env = self.env.as_ref().map(|env| {
-            env.iter()
-                .map(|(k, v)| {
-                    (
-                        k,
-                        if util::redact::should_redact(k) {
-                            "[REDACTED]"
-                        } else {
-                            v
-                        },
-                    )
-                })
-                .collect::<Vec<_>>()
-        });
-
-        f.debug_struct("AgentServerCommand")
-            .field("path", &self.path)
-            .field("args", &self.args)
-            .field("env", &filtered_env)
-            .finish()
-    }
-}
-
-impl settings::Settings for AllAgentServersSettings {
-    const KEY: Option<&'static str> = Some("agent_servers");
-
-    type FileContent = Self;
-
-    fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> Result<Self> {
-        let mut settings = AllAgentServersSettings::default();
-
-        for value in sources.defaults_and_customizations() {
-            if value.gemini.is_some() {
-                settings.gemini = value.gemini.clone();
-            }
-        }
-
-        Ok(settings)
-    }
-
-    fn import_from_vscode(_vscode: &settings::VsCodeSettings, _current: &mut Self::FileContent) {}
-}

crates/agent_servers/src/claude.rs

@@ -0,0 +1,705 @@
+mod mcp_server;
+mod tools;
+
+use collections::HashMap;
+use project::Project;
+use settings::SettingsStore;
+use std::cell::RefCell;
+use std::fmt::Display;
+use std::path::Path;
+use std::rc::Rc;
+
+use agentic_coding_protocol::{
+    self as acp, AnyAgentRequest, AnyAgentResult, Client, ProtocolVersion,
+    StreamAssistantMessageChunkParams, ToolCallContent, UpdateToolCallParams,
+};
+use anyhow::{Result, anyhow};
+use futures::channel::oneshot;
+use futures::future::LocalBoxFuture;
+use futures::{AsyncBufReadExt, AsyncWriteExt};
+use futures::{
+    AsyncRead, AsyncWrite, FutureExt, StreamExt,
+    channel::mpsc::{self, UnboundedReceiver, UnboundedSender},
+    io::BufReader,
+    select_biased,
+};
+use gpui::{App, AppContext, Entity, Task};
+use serde::{Deserialize, Serialize};
+use util::ResultExt;
+
+use crate::claude::mcp_server::ClaudeMcpServer;
+use crate::claude::tools::ClaudeTool;
+use crate::{AgentServer, AgentServerCommand, AllAgentServersSettings};
+use acp_thread::{AcpClientDelegate, AcpThread, AgentConnection};
+
+#[derive(Clone)]
+pub struct ClaudeCode;
+
+impl AgentServer for ClaudeCode {
+    fn name(&self) -> &'static str {
+        "Claude Code"
+    }
+
+    fn empty_state_headline(&self) -> &'static str {
+        self.name()
+    }
+
+    fn empty_state_message(&self) -> &'static str {
+        ""
+    }
+
+    fn logo(&self) -> ui::IconName {
+        ui::IconName::AiClaude
+    }
+
+    fn supports_always_allow(&self) -> bool {
+        false
+    }
+
+    fn new_thread(
+        &self,
+        root_dir: &Path,
+        project: &Entity<Project>,
+        cx: &mut App,
+    ) -> Task<Result<Entity<AcpThread>>> {
+        let project = project.clone();
+        let root_dir = root_dir.to_path_buf();
+        let title = self.name().into();
+        cx.spawn(async move |cx| {
+            let (mut delegate_tx, delegate_rx) = watch::channel(None);
+            let tool_id_map = Rc::new(RefCell::new(HashMap::default()));
+
+            let permission_mcp_server =
+                ClaudeMcpServer::new(delegate_rx, tool_id_map.clone(), cx).await?;
+
+            let mut mcp_servers = HashMap::default();
+            mcp_servers.insert(
+                mcp_server::SERVER_NAME.to_string(),
+                permission_mcp_server.server_config()?,
+            );
+            let mcp_config = McpConfig { mcp_servers };
+
+            let mcp_config_file = tempfile::NamedTempFile::new()?;
+            let (mcp_config_file, mcp_config_path) = mcp_config_file.into_parts();
+
+            let mut mcp_config_file = smol::fs::File::from(mcp_config_file);
+            mcp_config_file
+                .write_all(serde_json::to_string(&mcp_config)?.as_bytes())
+                .await?;
+            mcp_config_file.flush().await?;
+
+            let settings = cx.read_global(|settings: &SettingsStore, _| {
+                settings.get::<AllAgentServersSettings>(None).claude.clone()
+            })?;
+
+            let Some(command) =
+                AgentServerCommand::resolve("claude", &[], settings, &project, cx).await
+            else {
+                anyhow::bail!("Failed to find claude binary");
+            };
+
+            let mut child = util::command::new_smol_command(&command.path)
+                .args(
+                    [
+                        "--input-format",
+                        "stream-json",
+                        "--output-format",
+                        "stream-json",
+                        "--print",
+                        "--verbose",
+                        "--mcp-config",
+                        mcp_config_path.to_string_lossy().as_ref(),
+                        "--permission-prompt-tool",
+                        &format!(
+                            "mcp__{}__{}",
+                            mcp_server::SERVER_NAME,
+                            mcp_server::PERMISSION_TOOL
+                        ),
+                        "--allowedTools",
+                        "mcp__zed__Read,mcp__zed__Edit",
+                        "--disallowedTools",
+                        "Read,Edit",
+                    ]
+                    .into_iter()
+                    .chain(command.args.iter().map(|arg| arg.as_str())),
+                )
+                .current_dir(root_dir)
+                .stdin(std::process::Stdio::piped())
+                .stdout(std::process::Stdio::piped())
+                .stderr(std::process::Stdio::inherit())
+                .kill_on_drop(true)
+                .spawn()?;
+
+            let stdin = child.stdin.take().unwrap();
+            let stdout = child.stdout.take().unwrap();
+
+            let (incoming_message_tx, mut incoming_message_rx) = mpsc::unbounded();
+            let (outgoing_tx, outgoing_rx) = mpsc::unbounded();
+
+            let io_task =
+                ClaudeAgentConnection::handle_io(outgoing_rx, incoming_message_tx, stdin, stdout);
+            cx.background_spawn(async move {
+                io_task.await.log_err();
+                drop(mcp_config_path);
+                drop(child);
+            })
+            .detach();
+
+            cx.new(|cx| {
+                let end_turn_tx = Rc::new(RefCell::new(None));
+                let delegate = AcpClientDelegate::new(cx.entity().downgrade(), cx.to_async());
+                delegate_tx.send(Some(delegate.clone())).log_err();
+
+                let handler_task = cx.foreground_executor().spawn({
+                    let end_turn_tx = end_turn_tx.clone();
+                    let tool_id_map = tool_id_map.clone();
+                    async move {
+                        while let Some(message) = incoming_message_rx.next().await {
+                            ClaudeAgentConnection::handle_message(
+                                delegate.clone(),
+                                message,
+                                end_turn_tx.clone(),
+                                tool_id_map.clone(),
+                            )
+                            .await
+                        }
+                    }
+                });
+
+                let mut connection = ClaudeAgentConnection {
+                    outgoing_tx,
+                    end_turn_tx,
+                    _handler_task: handler_task,
+                    _mcp_server: None,
+                };
+
+                connection._mcp_server = Some(permission_mcp_server);
+                acp_thread::AcpThread::new(connection, title, None, project.clone(), cx)
+            })
+        })
+    }
+}
+
+impl AgentConnection for ClaudeAgentConnection {
+    /// Send a request to the agent and wait for a response.
+    fn request_any(
+        &self,
+        params: AnyAgentRequest,
+    ) -> LocalBoxFuture<'static, Result<acp::AnyAgentResult>> {
+        let end_turn_tx = self.end_turn_tx.clone();
+        let outgoing_tx = self.outgoing_tx.clone();
+        async move {
+            match params {
+                // todo: consider sending an empty request so we get the init response?
+                AnyAgentRequest::InitializeParams(_) => Ok(AnyAgentResult::InitializeResponse(
+                    acp::InitializeResponse {
+                        is_authenticated: true,
+                        protocol_version: ProtocolVersion::latest(),
+                    },
+                )),
+                AnyAgentRequest::AuthenticateParams(_) => {
+                    Err(anyhow!("Authentication not supported"))
+                }
+                AnyAgentRequest::SendUserMessageParams(message) => {
+                    let (tx, rx) = oneshot::channel();
+                    end_turn_tx.borrow_mut().replace(tx);
+                    let mut content = String::new();
+                    for chunk in message.chunks {
+                        match chunk {
+                            agentic_coding_protocol::UserMessageChunk::Text { text } => {
+                                content.push_str(&text)
+                            }
+                            agentic_coding_protocol::UserMessageChunk::Path { path } => {
+                                content.push_str(&format!("@{path:?}"))
+                            }
+                        }
+                    }
+                    outgoing_tx.unbounded_send(SdkMessage::User {
+                        message: Message {
+                            role: Role::User,
+                            content: Content::UntaggedText(content),
+                            id: None,
+                            model: None,
+                            stop_reason: None,
+                            stop_sequence: None,
+                            usage: None,
+                        },
+                        session_id: None,
+                    })?;
+                    rx.await??;
+                    Ok(AnyAgentResult::SendUserMessageResponse(
+                        acp::SendUserMessageResponse,
+                    ))
+                }
+                AnyAgentRequest::CancelSendMessageParams(_) => Ok(
+                    AnyAgentResult::CancelSendMessageResponse(acp::CancelSendMessageResponse),
+                ),
+            }
+        }
+        .boxed_local()
+    }
+}
+
+struct ClaudeAgentConnection {
+    outgoing_tx: UnboundedSender<SdkMessage>,
+    end_turn_tx: Rc<RefCell<Option<oneshot::Sender<Result<()>>>>>,
+    _mcp_server: Option<ClaudeMcpServer>,
+    _handler_task: Task<()>,
+}
+
+impl ClaudeAgentConnection {
+    async fn handle_message(
+        delegate: AcpClientDelegate,
+        message: SdkMessage,
+        end_turn_tx: Rc<RefCell<Option<oneshot::Sender<Result<()>>>>>,
+        tool_id_map: Rc<RefCell<HashMap<String, acp::ToolCallId>>>,
+    ) {
+        match message {
+            SdkMessage::Assistant { message, .. } | SdkMessage::User { message, .. } => {
+                for chunk in message.content.chunks() {
+                    match chunk {
+                        ContentChunk::Text { text } | ContentChunk::UntaggedText(text) => {
+                            delegate
+                                .stream_assistant_message_chunk(StreamAssistantMessageChunkParams {
+                                    chunk: acp::AssistantMessageChunk::Text { text },
+                                })
+                                .await
+                                .log_err();
+                        }
+                        ContentChunk::ToolUse { id, name, input } => {
+                            if let Some(resp) = delegate
+                                .push_tool_call(ClaudeTool::infer(&name, input).as_acp())
+                                .await
+                                .log_err()
+                            {
+                                tool_id_map.borrow_mut().insert(id, resp.id);
+                            }
+                        }
+                        ContentChunk::ToolResult {
+                            content,
+                            tool_use_id,
+                        } => {
+                            let id = tool_id_map.borrow_mut().remove(&tool_use_id);
+                            if let Some(id) = id {
+                                let content = content.to_string();
+                                delegate
+                                    .update_tool_call(UpdateToolCallParams {
+                                        tool_call_id: id,
+                                        status: acp::ToolCallStatus::Finished,
+                                        // Don't unset existing content
+                                        content: (!content.is_empty()).then_some(
+                                            ToolCallContent::Markdown {
+                                                // For now we only include text content
+                                                markdown: content,
+                                            },
+                                        ),
+                                    })
+                                    .await
+                                    .log_err();
+                            }
+                        }
+                        ContentChunk::Image
+                        | ContentChunk::Document
+                        | ContentChunk::Thinking
+                        | ContentChunk::RedactedThinking
+                        | ContentChunk::WebSearchToolResult => {
+                            delegate
+                                .stream_assistant_message_chunk(StreamAssistantMessageChunkParams {
+                                    chunk: acp::AssistantMessageChunk::Text {
+                                        text: format!("Unsupported content: {:?}", chunk),
+                                    },
+                                })
+                                .await
+                                .log_err();
+                        }
+                    }
+                }
+            }
+            SdkMessage::Result {
+                is_error, subtype, ..
+            } => {
+                if let Some(end_turn_tx) = end_turn_tx.borrow_mut().take() {
+                    if is_error {
+                        end_turn_tx.send(Err(anyhow!("Error: {subtype}"))).ok();
+                    } else {
+                        end_turn_tx.send(Ok(())).ok();
+                    }
+                }
+            }
+            SdkMessage::System { .. } => {}
+        }
+    }
+
+    async fn handle_io(
+        mut outgoing_rx: UnboundedReceiver<SdkMessage>,
+        incoming_tx: UnboundedSender<SdkMessage>,
+        mut outgoing_bytes: impl Unpin + AsyncWrite,
+        incoming_bytes: impl Unpin + AsyncRead,
+    ) -> Result<()> {
+        let mut output_reader = BufReader::new(incoming_bytes);
+        let mut outgoing_line = Vec::new();
+        let mut incoming_line = String::new();
+        loop {
+            select_biased! {
+                message = outgoing_rx.next() => {
+                    if let Some(message) = message {
+                        outgoing_line.clear();
+                        serde_json::to_writer(&mut outgoing_line, &message)?;
+                        log::trace!("send: {}", String::from_utf8_lossy(&outgoing_line));
+                        outgoing_line.push(b'\n');
+                        outgoing_bytes.write_all(&outgoing_line).await.ok();
+                    } else {
+                        break;
+                    }
+                }
+                bytes_read = output_reader.read_line(&mut incoming_line).fuse() => {
+                    if bytes_read? == 0 {
+                        break
+                    }
+                    log::trace!("recv: {}", &incoming_line);
+                    match serde_json::from_str::<SdkMessage>(&incoming_line) {
+                        Ok(message) => {
+                            incoming_tx.unbounded_send(message).log_err();
+                        }
+                        Err(error) => {
+                            log::error!("failed to parse incoming message: {error}. Raw: {incoming_line}");
+                        }
+                    }
+                    incoming_line.clear();
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct Message {
+    role: Role,
+    content: Content,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    model: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    stop_reason: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    stop_sequence: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    usage: Option<Usage>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+enum Content {
+    UntaggedText(String),
+    Chunks(Vec<ContentChunk>),
+}
+
+impl Content {
+    pub fn chunks(self) -> impl Iterator<Item = ContentChunk> {
+        match self {
+            Self::Chunks(chunks) => chunks.into_iter(),
+            Self::UntaggedText(text) => vec![ContentChunk::Text { text: text.clone() }].into_iter(),
+        }
+    }
+}
+
+impl Display for Content {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Content::UntaggedText(txt) => write!(f, "{}", txt),
+            Content::Chunks(chunks) => {
+                for chunk in chunks {
+                    write!(f, "{}", chunk)?;
+                }
+                Ok(())
+            }
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+enum ContentChunk {
+    Text {
+        text: String,
+    },
+    ToolUse {
+        id: String,
+        name: String,
+        input: serde_json::Value,
+    },
+    ToolResult {
+        content: Content,
+        tool_use_id: String,
+    },
+    // TODO
+    Image,
+    Document,
+    Thinking,
+    RedactedThinking,
+    WebSearchToolResult,
+    #[serde(untagged)]
+    UntaggedText(String),
+}
+
+impl Display for ContentChunk {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ContentChunk::Text { text } => write!(f, "{}", text),
+            ContentChunk::UntaggedText(text) => write!(f, "{}", text),
+            ContentChunk::ToolResult { content, .. } => write!(f, "{}", content),
+            ContentChunk::Image
+            | ContentChunk::Document
+            | ContentChunk::Thinking
+            | ContentChunk::RedactedThinking
+            | ContentChunk::ToolUse { .. }
+            | ContentChunk::WebSearchToolResult => {
+                write!(f, "\n{:?}\n", &self)
+            }
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct Usage {
+    input_tokens: u32,
+    cache_creation_input_tokens: u32,
+    cache_read_input_tokens: u32,
+    output_tokens: u32,
+    service_tier: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+enum Role {
+    System,
+    Assistant,
+    User,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct MessageParam {
+    role: Role,
+    content: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+enum SdkMessage {
+    // An assistant message
+    Assistant {
+        message: Message, // from Anthropic SDK
+        #[serde(skip_serializing_if = "Option::is_none")]
+        session_id: Option<String>,
+    },
+
+    // A user message
+    User {
+        message: Message, // from Anthropic SDK
+        #[serde(skip_serializing_if = "Option::is_none")]
+        session_id: Option<String>,
+    },
+
+    // Emitted as the last message in a conversation
+    Result {
+        subtype: ResultErrorType,
+        duration_ms: f64,
+        duration_api_ms: f64,
+        is_error: bool,
+        num_turns: i32,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        result: Option<String>,
+        session_id: String,
+        total_cost_usd: f64,
+    },
+    // Emitted as the first message at the start of a conversation
+    System {
+        cwd: String,
+        session_id: String,
+        tools: Vec<String>,
+        model: String,
+        mcp_servers: Vec<McpServer>,
+        #[serde(rename = "apiKeySource")]
+        api_key_source: String,
+        #[serde(rename = "permissionMode")]
+        permission_mode: PermissionMode,
+    },
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+enum ResultErrorType {
+    Success,
+    ErrorMaxTurns,
+    ErrorDuringExecution,
+}
+
+impl Display for ResultErrorType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ResultErrorType::Success => write!(f, "success"),
+            ResultErrorType::ErrorMaxTurns => write!(f, "error_max_turns"),
+            ResultErrorType::ErrorDuringExecution => write!(f, "error_during_execution"),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct McpServer {
+    name: String,
+    status: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+enum PermissionMode {
+    Default,
+    AcceptEdits,
+    BypassPermissions,
+    Plan,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct McpConfig {
+    mcp_servers: HashMap<String, McpServerConfig>,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct McpServerConfig {
+    command: String,
+    args: Vec<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    env: Option<HashMap<String, String>>,
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+    use super::*;
+    use serde_json::json;
+
+    crate::common_e2e_tests!(ClaudeCode);
+
+    pub fn local_command() -> AgentServerCommand {
+        AgentServerCommand {
+            path: "claude".into(),
+            args: vec![],
+            env: None,
+        }
+    }
+
+    #[test]
+    fn test_deserialize_content_untagged_text() {
+        let json = json!("Hello, world!");
+        let content: Content = serde_json::from_value(json).unwrap();
+        match content {
+            Content::UntaggedText(text) => assert_eq!(text, "Hello, world!"),
+            _ => panic!("Expected UntaggedText variant"),
+        }
+    }
+
+    #[test]
+    fn test_deserialize_content_chunks() {
+        let json = json!([
+            {
+                "type": "text",
+                "text": "Hello"
+            },
+            {
+                "type": "tool_use",
+                "id": "tool_123",
+                "name": "calculator",
+                "input": {"operation": "add", "a": 1, "b": 2}
+            }
+        ]);
+        let content: Content = serde_json::from_value(json).unwrap();
+        match content {
+            Content::Chunks(chunks) => {
+                assert_eq!(chunks.len(), 2);
+                match &chunks[0] {
+                    ContentChunk::Text { text } => assert_eq!(text, "Hello"),
+                    _ => panic!("Expected Text chunk"),
+                }
+                match &chunks[1] {
+                    ContentChunk::ToolUse { id, name, input } => {
+                        assert_eq!(id, "tool_123");
+                        assert_eq!(name, "calculator");
+                        assert_eq!(input["operation"], "add");
+                        assert_eq!(input["a"], 1);
+                        assert_eq!(input["b"], 2);
+                    }
+                    _ => panic!("Expected ToolUse chunk"),
+                }
+            }
+            _ => panic!("Expected Chunks variant"),
+        }
+    }
+
+    #[test]
+    fn test_deserialize_tool_result_untagged_text() {
+        let json = json!({
+            "type": "tool_result",
+            "content": "Result content",
+            "tool_use_id": "tool_456"
+        });
+        let chunk: ContentChunk = serde_json::from_value(json).unwrap();
+        match chunk {
+            ContentChunk::ToolResult {
+                content,
+                tool_use_id,
+            } => {
+                match content {
+                    Content::UntaggedText(text) => assert_eq!(text, "Result content"),
+                    _ => panic!("Expected UntaggedText content"),
+                }
+                assert_eq!(tool_use_id, "tool_456");
+            }
+            _ => panic!("Expected ToolResult variant"),
+        }
+    }
+
+    #[test]
+    fn test_deserialize_tool_result_chunks() {
+        let json = json!({
+            "type": "tool_result",
+            "content": [
+                {
+                    "type": "text",
+                    "text": "Processing complete"
+                },
+                {
+                    "type": "text",
+                    "text": "Result: 42"
+                }
+            ],
+            "tool_use_id": "tool_789"
+        });
+        let chunk: ContentChunk = serde_json::from_value(json).unwrap();
+        match chunk {
+            ContentChunk::ToolResult {
+                content,
+                tool_use_id,
+            } => {
+                match content {
+                    Content::Chunks(chunks) => {
+                        assert_eq!(chunks.len(), 2);
+                        match &chunks[0] {
+                            ContentChunk::Text { text } => assert_eq!(text, "Processing complete"),
+                            _ => panic!("Expected Text chunk"),
+                        }
+                        match &chunks[1] {
+                            ContentChunk::Text { text } => assert_eq!(text, "Result: 42"),
+                            _ => panic!("Expected Text chunk"),
+                        }
+                    }
+                    _ => panic!("Expected Chunks content"),
+                }
+                assert_eq!(tool_use_id, "tool_789");
+            }
+            _ => panic!("Expected ToolResult variant"),
+        }
+    }
+}

crates/agent_servers/src/claude/mcp_server.rs

@@ -0,0 +1,303 @@
+use std::{cell::RefCell, rc::Rc};
+
+use acp_thread::AcpClientDelegate;
+use agentic_coding_protocol::{self as acp, Client, ReadTextFileParams, WriteTextFileParams};
+use anyhow::{Context, Result};
+use collections::HashMap;
+use context_server::{
+    listener::McpServer,
+    types::{
+        CallToolParams, CallToolResponse, Implementation, InitializeParams, InitializeResponse,
+        ListToolsResponse, ProtocolVersion, ServerCapabilities, Tool, ToolAnnotations,
+        ToolResponseContent, ToolsCapabilities, requests,
+    },
+};
+use gpui::{App, AsyncApp, Task};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use util::debug_panic;
+
+use crate::claude::{
+    McpServerConfig,
+    tools::{ClaudeTool, EditToolParams, EditToolResponse, ReadToolParams, ReadToolResponse},
+};
+
+pub struct ClaudeMcpServer {
+    server: McpServer,
+}
+
+pub const SERVER_NAME: &str = "zed";
+pub const READ_TOOL: &str = "Read";
+pub const EDIT_TOOL: &str = "Edit";
+pub const PERMISSION_TOOL: &str = "Confirmation";
+
+#[derive(Deserialize, JsonSchema, Debug)]
+struct PermissionToolParams {
+    tool_name: String,
+    input: serde_json::Value,
+    tool_use_id: Option<String>,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct PermissionToolResponse {
+    behavior: PermissionToolBehavior,
+    updated_input: serde_json::Value,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "snake_case")]
+enum PermissionToolBehavior {
+    Allow,
+    Deny,
+}
+
+impl ClaudeMcpServer {
+    pub async fn new(
+        delegate: watch::Receiver<Option<AcpClientDelegate>>,
+        tool_id_map: Rc<RefCell<HashMap<String, acp::ToolCallId>>>,
+        cx: &AsyncApp,
+    ) -> Result<Self> {
+        let mut mcp_server = McpServer::new(cx).await?;
+        mcp_server.handle_request::<requests::Initialize>(Self::handle_initialize);
+        mcp_server.handle_request::<requests::ListTools>(Self::handle_list_tools);
+        mcp_server.handle_request::<requests::CallTool>(move |request, cx| {
+            Self::handle_call_tool(request, delegate.clone(), tool_id_map.clone(), cx)
+        });
+
+        Ok(Self { server: mcp_server })
+    }
+
+    pub fn server_config(&self) -> Result<McpServerConfig> {
+        #[cfg(not(target_os = "windows"))]
+        let zed_path = util::get_shell_safe_zed_path()?;
+        #[cfg(target_os = "windows")]
+        let zed_path = std::env::current_exe()
+            .context("finding current executable path for use in mcp_server")?
+            .to_string_lossy()
+            .to_string();
+
+        Ok(McpServerConfig {
+            command: zed_path,
+            args: vec![
+                "--nc".into(),
+                self.server.socket_path().display().to_string(),
+            ],
+            env: None,
+        })
+    }
+
+    fn handle_initialize(_: InitializeParams, cx: &App) -> Task<Result<InitializeResponse>> {
+        cx.foreground_executor().spawn(async move {
+            Ok(InitializeResponse {
+                protocol_version: ProtocolVersion("2025-06-18".into()),
+                capabilities: ServerCapabilities {
+                    experimental: None,
+                    logging: None,
+                    completions: None,
+                    prompts: None,
+                    resources: None,
+                    tools: Some(ToolsCapabilities {
+                        list_changed: Some(false),
+                    }),
+                },
+                server_info: Implementation {
+                    name: SERVER_NAME.into(),
+                    version: "0.1.0".into(),
+                },
+                meta: None,
+            })
+        })
+    }
+
+    fn handle_list_tools(_: (), cx: &App) -> Task<Result<ListToolsResponse>> {
+        cx.foreground_executor().spawn(async move {
+            Ok(ListToolsResponse {
+                tools: vec![
+                    Tool {
+                        name: PERMISSION_TOOL.into(),
+                        input_schema: schemars::schema_for!(PermissionToolParams).into(),
+                        description: None,
+                        annotations: None,
+                    },
+                    Tool {
+                        name: READ_TOOL.into(),
+                        input_schema: schemars::schema_for!(ReadToolParams).into(),
+                        description: Some("Read the contents of a file. In sessions with mcp__zed__Read always use it instead of Read as it contains the most up-to-date contents.".to_string()),
+                        annotations: Some(ToolAnnotations {
+                            title: Some("Read file".to_string()),
+                            read_only_hint: Some(true),
+                            destructive_hint: Some(false),
+                            open_world_hint: Some(false),
+                            // if time passes the contents might change, but it's not going to do anything different
+                            // true or false seem too strong, let's try a none.
+                            idempotent_hint: None,
+                        }),
+                    },
+                    Tool {
+                        name: EDIT_TOOL.into(),
+                        input_schema: schemars::schema_for!(EditToolParams).into(),
+                        description: Some("Edits a file. In sessions with mcp__zed__Edit always use it instead of Edit as it will show the diff to the user better.".to_string()),
+                        annotations: Some(ToolAnnotations {
+                            title: Some("Edit file".to_string()),
+                            read_only_hint: Some(false),
+                            destructive_hint: Some(false),
+                            open_world_hint: Some(false),
+                            idempotent_hint: Some(false),
+                        }),
+                    },
+                ],
+                next_cursor: None,
+                meta: None,
+            })
+        })
+    }
+
+    fn handle_call_tool(
+        request: CallToolParams,
+        mut delegate_watch: watch::Receiver<Option<AcpClientDelegate>>,
+        tool_id_map: Rc<RefCell<HashMap<String, acp::ToolCallId>>>,
+        cx: &App,
+    ) -> Task<Result<CallToolResponse>> {
+        cx.spawn(async move |cx| {
+            let Some(delegate) = delegate_watch.recv().await? else {
+                debug_panic!("Sent None delegate");
+                anyhow::bail!("Server not available");
+            };
+
+            if request.name.as_str() == PERMISSION_TOOL {
+                let input =
+                    serde_json::from_value(request.arguments.context("Arguments required")?)?;
+
+                let result =
+                    Self::handle_permissions_tool_call(input, delegate, tool_id_map, cx).await?;
+                Ok(CallToolResponse {
+                    content: vec![ToolResponseContent::Text {
+                        text: serde_json::to_string(&result)?,
+                    }],
+                    is_error: None,
+                    meta: None,
+                })
+            } else if request.name.as_str() == READ_TOOL {
+                let input =
+                    serde_json::from_value(request.arguments.context("Arguments required")?)?;
+
+                let result = Self::handle_read_tool_call(input, delegate, cx).await?;
+                Ok(CallToolResponse {
+                    content: vec![ToolResponseContent::Text {
+                        text: serde_json::to_string(&result)?,
+                    }],
+                    is_error: None,
+                    meta: None,
+                })
+            } else if request.name.as_str() == EDIT_TOOL {
+                let input =
+                    serde_json::from_value(request.arguments.context("Arguments required")?)?;
+
+                let result = Self::handle_edit_tool_call(input, delegate, cx).await?;
+                Ok(CallToolResponse {
+                    content: vec![ToolResponseContent::Text {
+                        text: serde_json::to_string(&result)?,
+                    }],
+                    is_error: None,
+                    meta: None,
+                })
+            } else {
+                anyhow::bail!("Unsupported tool");
+            }
+        })
+    }
+
+    fn handle_read_tool_call(
+        params: ReadToolParams,
+        delegate: AcpClientDelegate,
+        cx: &AsyncApp,
+    ) -> Task<Result<ReadToolResponse>> {
+        cx.foreground_executor().spawn(async move {
+            let response = delegate
+                .read_text_file(ReadTextFileParams {
+                    path: params.abs_path,
+                    line: params.offset,
+                    limit: params.limit,
+                })
+                .await?;
+
+            Ok(ReadToolResponse {
+                content: response.content,
+            })
+        })
+    }
+
+    fn handle_edit_tool_call(
+        params: EditToolParams,
+        delegate: AcpClientDelegate,
+        cx: &AsyncApp,
+    ) -> Task<Result<EditToolResponse>> {
+        cx.foreground_executor().spawn(async move {
+            let response = delegate
+                .read_text_file_reusing_snapshot(ReadTextFileParams {
+                    path: params.abs_path.clone(),
+                    line: None,
+                    limit: None,
+                })
+                .await?;
+
+            let new_content = response.content.replace(&params.old_text, &params.new_text);
+            if new_content == response.content {
+                return Err(anyhow::anyhow!("The old_text was not found in the content"));
+            }
+
+            delegate
+                .write_text_file(WriteTextFileParams {
+                    path: params.abs_path,
+                    content: new_content,
+                })
+                .await?;
+
+            Ok(EditToolResponse)
+        })
+    }
+
+    fn handle_permissions_tool_call(
+        params: PermissionToolParams,
+        delegate: AcpClientDelegate,
+        tool_id_map: Rc<RefCell<HashMap<String, acp::ToolCallId>>>,
+        cx: &AsyncApp,
+    ) -> Task<Result<PermissionToolResponse>> {
+        cx.foreground_executor().spawn(async move {
+            let claude_tool = ClaudeTool::infer(&params.tool_name, params.input.clone());
+
+            let tool_call_id = match params.tool_use_id {
+                Some(tool_use_id) => tool_id_map
+                    .borrow()
+                    .get(&tool_use_id)
+                    .cloned()
+                    .context("Tool call ID not found")?,
+
+                None => delegate.push_tool_call(claude_tool.as_acp()).await?.id,
+            };
+
+            let outcome = delegate
+                .request_existing_tool_call_confirmation(
+                    tool_call_id,
+                    claude_tool.confirmation(None),
+                )
+                .await?;
+
+            match outcome {
+                acp::ToolCallConfirmationOutcome::Allow
+                | acp::ToolCallConfirmationOutcome::AlwaysAllow
+                | acp::ToolCallConfirmationOutcome::AlwaysAllowMcpServer
+                | acp::ToolCallConfirmationOutcome::AlwaysAllowTool => Ok(PermissionToolResponse {
+                    behavior: PermissionToolBehavior::Allow,
+                    updated_input: params.input,
+                }),
+                acp::ToolCallConfirmationOutcome::Reject
+                | acp::ToolCallConfirmationOutcome::Cancel => Ok(PermissionToolResponse {
+                    behavior: PermissionToolBehavior::Deny,
+                    updated_input: params.input,
+                }),
+            }
+        })
+    }
+}

crates/agent_servers/src/claude/tools.rs

@@ -0,0 +1,763 @@
+use std::path::PathBuf;
+
+use agentic_coding_protocol::{self as acp, PushToolCallParams, ToolCallLocation};
+use itertools::Itertools;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use util::ResultExt;
+
+pub enum ClaudeTool {
+    Task(Option<TaskToolParams>),
+    NotebookRead(Option<NotebookReadToolParams>),
+    NotebookEdit(Option<NotebookEditToolParams>),
+    Edit(Option<EditToolParams>),
+    MultiEdit(Option<MultiEditToolParams>),
+    ReadFile(Option<ReadToolParams>),
+    Write(Option<WriteToolParams>),
+    Ls(Option<LsToolParams>),
+    Glob(Option<GlobToolParams>),
+    Grep(Option<GrepToolParams>),
+    Terminal(Option<BashToolParams>),
+    WebFetch(Option<WebFetchToolParams>),
+    WebSearch(Option<WebSearchToolParams>),
+    TodoWrite(Option<TodoWriteToolParams>),
+    ExitPlanMode(Option<ExitPlanModeToolParams>),
+    Other {
+        name: String,
+        input: serde_json::Value,
+    },
+}
+
+impl ClaudeTool {
+    pub fn infer(tool_name: &str, input: serde_json::Value) -> Self {
+        match tool_name {
+            // Known tools
+            "mcp__zed__Read" => Self::ReadFile(serde_json::from_value(input).log_err()),
+            "mcp__zed__Edit" => Self::Edit(serde_json::from_value(input).log_err()),
+            "MultiEdit" => Self::MultiEdit(serde_json::from_value(input).log_err()),
+            "Write" => Self::Write(serde_json::from_value(input).log_err()),
+            "LS" => Self::Ls(serde_json::from_value(input).log_err()),
+            "Glob" => Self::Glob(serde_json::from_value(input).log_err()),
+            "Grep" => Self::Grep(serde_json::from_value(input).log_err()),
+            "Bash" => Self::Terminal(serde_json::from_value(input).log_err()),
+            "WebFetch" => Self::WebFetch(serde_json::from_value(input).log_err()),
+            "WebSearch" => Self::WebSearch(serde_json::from_value(input).log_err()),
+            "TodoWrite" => Self::TodoWrite(serde_json::from_value(input).log_err()),
+            "exit_plan_mode" => Self::ExitPlanMode(serde_json::from_value(input).log_err()),
+            "Task" => Self::Task(serde_json::from_value(input).log_err()),
+            "NotebookRead" => Self::NotebookRead(serde_json::from_value(input).log_err()),
+            "NotebookEdit" => Self::NotebookEdit(serde_json::from_value(input).log_err()),
+            // Inferred from name
+            _ => {
+                let tool_name = tool_name.to_lowercase();
+
+                if tool_name.contains("edit") || tool_name.contains("write") {
+                    Self::Edit(None)
+                } else if tool_name.contains("terminal") {
+                    Self::Terminal(None)
+                } else {
+                    Self::Other {
+                        name: tool_name.to_string(),
+                        input,
+                    }
+                }
+            }
+        }
+    }
+
+    pub fn label(&self) -> String {
+        match &self {
+            Self::Task(Some(params)) => params.description.clone(),
+            Self::Task(None) => "Task".into(),
+            Self::NotebookRead(Some(params)) => {
+                format!("Read Notebook {}", params.notebook_path.display())
+            }
+            Self::NotebookRead(None) => "Read Notebook".into(),
+            Self::NotebookEdit(Some(params)) => {
+                format!("Edit Notebook {}", params.notebook_path.display())
+            }
+            Self::NotebookEdit(None) => "Edit Notebook".into(),
+            Self::Terminal(Some(params)) => format!("`{}`", params.command),
+            Self::Terminal(None) => "Terminal".into(),
+            Self::ReadFile(_) => "Read File".into(),
+            Self::Ls(Some(params)) => {
+                format!("List Directory {}", params.path.display())
+            }
+            Self::Ls(None) => "List Directory".into(),
+            Self::Edit(Some(params)) => {
+                format!("Edit {}", params.abs_path.display())
+            }
+            Self::Edit(None) => "Edit".into(),
+            Self::MultiEdit(Some(params)) => {
+                format!("Multi Edit {}", params.file_path.display())
+            }
+            Self::MultiEdit(None) => "Multi Edit".into(),
+            Self::Write(Some(params)) => {
+                format!("Write {}", params.file_path.display())
+            }
+            Self::Write(None) => "Write".into(),
+            Self::Glob(Some(params)) => {
+                format!("Glob `{params}`")
+            }
+            Self::Glob(None) => "Glob".into(),
+            Self::Grep(Some(params)) => format!("`{params}`"),
+            Self::Grep(None) => "Grep".into(),
+            Self::WebFetch(Some(params)) => format!("Fetch {}", params.url),
+            Self::WebFetch(None) => "Fetch".into(),
+            Self::WebSearch(Some(params)) => format!("Web Search: {}", params),
+            Self::WebSearch(None) => "Web Search".into(),
+            Self::TodoWrite(Some(params)) => format!(
+                "Update TODOs: {}",
+                params.todos.iter().map(|todo| &todo.content).join(", ")
+            ),
+            Self::TodoWrite(None) => "Update TODOs".into(),
+            Self::ExitPlanMode(_) => "Exit Plan Mode".into(),
+            Self::Other { name, .. } => name.clone(),
+        }
+    }
+
+    pub fn content(&self) -> Option<acp::ToolCallContent> {
+        match &self {
+            Self::Other { input, .. } => Some(acp::ToolCallContent::Markdown {
+                markdown: format!(
+                    "```json\n{}```",
+                    serde_json::to_string_pretty(&input).unwrap_or("{}".to_string())
+                ),
+            }),
+            Self::Task(Some(params)) => Some(acp::ToolCallContent::Markdown {
+                markdown: params.prompt.clone(),
+            }),
+            Self::NotebookRead(Some(params)) => Some(acp::ToolCallContent::Markdown {
+                markdown: params.notebook_path.display().to_string(),
+            }),
+            Self::NotebookEdit(Some(params)) => Some(acp::ToolCallContent::Markdown {
+                markdown: params.new_source.clone(),
+            }),
+            Self::Terminal(Some(params)) => Some(acp::ToolCallContent::Markdown {
+                markdown: format!(
+                    "`{}`\n\n{}",
+                    params.command,
+                    params.description.as_deref().unwrap_or_default()
+                ),
+            }),
+            Self::ReadFile(Some(params)) => Some(acp::ToolCallContent::Markdown {
+                markdown: params.abs_path.display().to_string(),
+            }),
+            Self::Ls(Some(params)) => Some(acp::ToolCallContent::Markdown {
+                markdown: params.path.display().to_string(),
+            }),
+            Self::Glob(Some(params)) => Some(acp::ToolCallContent::Markdown {
+                markdown: params.to_string(),
+            }),
+            Self::Grep(Some(params)) => Some(acp::ToolCallContent::Markdown {
+                markdown: format!("`{params}`"),
+            }),
+            Self::WebFetch(Some(params)) => Some(acp::ToolCallContent::Markdown {
+                markdown: params.prompt.clone(),
+            }),
+            Self::WebSearch(Some(params)) => Some(acp::ToolCallContent::Markdown {
+                markdown: params.to_string(),
+            }),
+            Self::TodoWrite(Some(params)) => Some(acp::ToolCallContent::Markdown {
+                markdown: params
+                    .todos
+                    .iter()
+                    .map(|todo| {
+                        format!(
+                            "- {} {}: {}",
+                            match todo.status {
+                                TodoStatus::Completed => "✅",
+                                TodoStatus::InProgress => "🚧",
+                                TodoStatus::Pending => "⬜",
+                            },
+                            todo.priority,
+                            todo.content
+                        )
+                    })
+                    .join("\n"),
+            }),
+            Self::ExitPlanMode(Some(params)) => Some(acp::ToolCallContent::Markdown {
+                markdown: params.plan.clone(),
+            }),
+            Self::Edit(Some(params)) => Some(acp::ToolCallContent::Diff {
+                diff: acp::Diff {
+                    path: params.abs_path.clone(),
+                    old_text: Some(params.old_text.clone()),
+                    new_text: params.new_text.clone(),
+                },
+            }),
+            Self::Write(Some(params)) => Some(acp::ToolCallContent::Diff {
+                diff: acp::Diff {
+                    path: params.file_path.clone(),
+                    old_text: None,
+                    new_text: params.content.clone(),
+                },
+            }),
+            Self::MultiEdit(Some(params)) => {
+                // todo: show multiple edits in a multibuffer?
+                params.edits.first().map(|edit| acp::ToolCallContent::Diff {
+                    diff: acp::Diff {
+                        path: params.file_path.clone(),
+                        old_text: Some(edit.old_string.clone()),
+                        new_text: edit.new_string.clone(),
+                    },
+                })
+            }
+            Self::Task(None)
+            | Self::NotebookRead(None)
+            | Self::NotebookEdit(None)
+            | Self::Terminal(None)
+            | Self::ReadFile(None)
+            | Self::Ls(None)
+            | Self::Glob(None)
+            | Self::Grep(None)
+            | Self::WebFetch(None)
+            | Self::WebSearch(None)
+            | Self::TodoWrite(None)
+            | Self::ExitPlanMode(None)
+            | Self::Edit(None)
+            | Self::Write(None)
+            | Self::MultiEdit(None) => None,
+        }
+    }
+
+    pub fn icon(&self) -> acp::Icon {
+        match self {
+            Self::Task(_) => acp::Icon::Hammer,
+            Self::NotebookRead(_) => acp::Icon::FileSearch,
+            Self::NotebookEdit(_) => acp::Icon::Pencil,
+            Self::Edit(_) => acp::Icon::Pencil,
+            Self::MultiEdit(_) => acp::Icon::Pencil,
+            Self::Write(_) => acp::Icon::Pencil,
+            Self::ReadFile(_) => acp::Icon::FileSearch,
+            Self::Ls(_) => acp::Icon::Folder,
+            Self::Glob(_) => acp::Icon::FileSearch,
+            Self::Grep(_) => acp::Icon::Regex,
+            Self::Terminal(_) => acp::Icon::Terminal,
+            Self::WebSearch(_) => acp::Icon::Globe,
+            Self::WebFetch(_) => acp::Icon::Globe,
+            Self::TodoWrite(_) => acp::Icon::LightBulb,
+            Self::ExitPlanMode(_) => acp::Icon::Hammer,
+            Self::Other { .. } => acp::Icon::Hammer,
+        }
+    }
+
+    pub fn confirmation(&self, description: Option<String>) -> acp::ToolCallConfirmation {
+        match &self {
+            Self::Edit(_) | Self::Write(_) | Self::NotebookEdit(_) | Self::MultiEdit(_) => {
+                acp::ToolCallConfirmation::Edit { description }
+            }
+            Self::WebFetch(params) => acp::ToolCallConfirmation::Fetch {
+                urls: params
+                    .as_ref()
+                    .map(|p| vec![p.url.clone()])
+                    .unwrap_or_default(),
+                description,
+            },
+            Self::Terminal(Some(BashToolParams {
+                description,
+                command,
+                ..
+            })) => acp::ToolCallConfirmation::Execute {
+                command: command.clone(),
+                root_command: command.clone(),
+                description: description.clone(),
+            },
+            Self::ExitPlanMode(Some(params)) => acp::ToolCallConfirmation::Other {
+                description: if let Some(description) = description {
+                    format!("{description} {}", params.plan)
+                } else {
+                    params.plan.clone()
+                },
+            },
+            Self::Task(Some(params)) => acp::ToolCallConfirmation::Other {
+                description: if let Some(description) = description {
+                    format!("{description} {}", params.description)
+                } else {
+                    params.description.clone()
+                },
+            },
+            Self::Ls(Some(LsToolParams { path, .. }))
+            | Self::ReadFile(Some(ReadToolParams { abs_path: path, .. })) => {
+                let path = path.display();
+                acp::ToolCallConfirmation::Other {
+                    description: if let Some(description) = description {
+                        format!("{description} {path}")
+                    } else {
+                        path.to_string()
+                    },
+                }
+            }
+            Self::NotebookRead(Some(NotebookReadToolParams { notebook_path, .. })) => {
+                let path = notebook_path.display();
+                acp::ToolCallConfirmation::Other {
+                    description: if let Some(description) = description {
+                        format!("{description} {path}")
+                    } else {
+                        path.to_string()
+                    },
+                }
+            }
+            Self::Glob(Some(params)) => acp::ToolCallConfirmation::Other {
+                description: if let Some(description) = description {
+                    format!("{description} {params}")
+                } else {
+                    params.to_string()
+                },
+            },
+            Self::Grep(Some(params)) => acp::ToolCallConfirmation::Other {
+                description: if let Some(description) = description {
+                    format!("{description} {params}")
+                } else {
+                    params.to_string()
+                },
+            },
+            Self::WebSearch(Some(params)) => acp::ToolCallConfirmation::Other {
+                description: if let Some(description) = description {
+                    format!("{description} {params}")
+                } else {
+                    params.to_string()
+                },
+            },
+            Self::TodoWrite(Some(params)) => {
+                let params = params.todos.iter().map(|todo| &todo.content).join(", ");
+                acp::ToolCallConfirmation::Other {
+                    description: if let Some(description) = description {
+                        format!("{description} {params}")
+                    } else {
+                        params
+                    },
+                }
+            }
+            Self::Terminal(None)
+            | Self::Task(None)
+            | Self::NotebookRead(None)
+            | Self::ExitPlanMode(None)
+            | Self::Ls(None)
+            | Self::Glob(None)
+            | Self::Grep(None)
+            | Self::ReadFile(None)
+            | Self::WebSearch(None)
+            | Self::TodoWrite(None)
+            | Self::Other { .. } => acp::ToolCallConfirmation::Other {
+                description: description.unwrap_or("".to_string()),
+            },
+        }
+    }
+
+    pub fn locations(&self) -> Vec<acp::ToolCallLocation> {
+        match &self {
+            Self::Edit(Some(EditToolParams { abs_path, .. })) => vec![ToolCallLocation {
+                path: abs_path.clone(),
+                line: None,
+            }],
+            Self::MultiEdit(Some(MultiEditToolParams { file_path, .. })) => {
+                vec![ToolCallLocation {
+                    path: file_path.clone(),
+                    line: None,
+                }]
+            }
+            Self::Write(Some(WriteToolParams { file_path, .. })) => vec![ToolCallLocation {
+                path: file_path.clone(),
+                line: None,
+            }],
+            Self::ReadFile(Some(ReadToolParams {
+                abs_path, offset, ..
+            })) => vec![ToolCallLocation {
+                path: abs_path.clone(),
+                line: *offset,
+            }],
+            Self::NotebookRead(Some(NotebookReadToolParams { notebook_path, .. })) => {
+                vec![ToolCallLocation {
+                    path: notebook_path.clone(),
+                    line: None,
+                }]
+            }
+            Self::NotebookEdit(Some(NotebookEditToolParams { notebook_path, .. })) => {
+                vec![ToolCallLocation {
+                    path: notebook_path.clone(),
+                    line: None,
+                }]
+            }
+            Self::Glob(Some(GlobToolParams {
+                path: Some(path), ..
+            })) => vec![ToolCallLocation {
+                path: path.clone(),
+                line: None,
+            }],
+            Self::Ls(Some(LsToolParams { path, .. })) => vec![ToolCallLocation {
+                path: path.clone(),
+                line: None,
+            }],
+            Self::Grep(Some(GrepToolParams {
+                path: Some(path), ..
+            })) => vec![ToolCallLocation {
+                path: PathBuf::from(path),
+                line: None,
+            }],
+            Self::Task(_)
+            | Self::NotebookRead(None)
+            | Self::NotebookEdit(None)
+            | Self::Edit(None)
+            | Self::MultiEdit(None)
+            | Self::Write(None)
+            | Self::ReadFile(None)
+            | Self::Ls(None)
+            | Self::Glob(_)
+            | Self::Grep(_)
+            | Self::Terminal(_)
+            | Self::WebFetch(_)
+            | Self::WebSearch(_)
+            | Self::TodoWrite(_)
+            | Self::ExitPlanMode(_)
+            | Self::Other { .. } => vec![],
+        }
+    }
+
+    pub fn as_acp(&self) -> PushToolCallParams {
+        PushToolCallParams {
+            label: self.label(),
+            content: self.content(),
+            icon: self.icon(),
+            locations: self.locations(),
+        }
+    }
+}
+
+#[derive(Deserialize, JsonSchema, Debug)]
+pub struct EditToolParams {
+    /// The absolute path to the file to read.
+    pub abs_path: PathBuf,
+    /// The old text to replace (must be unique in the file)
+    pub old_text: String,
+    /// The new text.
+    pub new_text: String,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EditToolResponse;
+
+#[derive(Deserialize, JsonSchema, Debug)]
+pub struct ReadToolParams {
+    /// The absolute path to the file to read.
+    pub abs_path: PathBuf,
+    /// Which line to start reading from. Omit to start from the beginning.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub offset: Option<u32>,
+    /// How many lines to read. Omit for the whole file.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub limit: Option<u32>,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ReadToolResponse {
+    pub content: String,
+}
+
+#[derive(Deserialize, JsonSchema, Debug)]
+pub struct WriteToolParams {
+    /// Absolute path for new file
+    pub file_path: PathBuf,
+    /// File content
+    pub content: String,
+}
+
+#[derive(Deserialize, JsonSchema, Debug)]
+pub struct BashToolParams {
+    /// Shell command to execute
+    pub command: String,
+    /// 5-10 word description of what command does
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    /// Timeout in ms (max 600000ms/10min, default 120000ms)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub timeout: Option<u32>,
+}
+
+#[derive(Deserialize, JsonSchema, Debug)]
+pub struct GlobToolParams {
+    /// Glob pattern like **/*.js or src/**/*.ts
+    pub pattern: String,
+    /// Directory to search in (omit for current directory)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub path: Option<PathBuf>,
+}
+
+impl std::fmt::Display for GlobToolParams {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Some(path) = &self.path {
+            write!(f, "{}", path.display())?;
+        }
+        write!(f, "{}", self.pattern)
+    }
+}
+
+#[derive(Deserialize, JsonSchema, Debug)]
+pub struct LsToolParams {
+    /// Absolute path to directory
+    pub path: PathBuf,
+    /// Array of glob patterns to ignore
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub ignore: Vec<String>,
+}
+
+#[derive(Deserialize, JsonSchema, Debug)]
+pub struct GrepToolParams {
+    /// Regex pattern to search for
+    pub pattern: String,
+    /// File/directory to search (defaults to current directory)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+    /// "content" (shows lines), "files_with_matches" (default), "count"
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub output_mode: Option<GrepOutputMode>,
+    /// Filter files with glob pattern like "*.js"
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub glob: Option<String>,
+    /// File type filter like "js", "py", "rust"
+    #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
+    pub file_type: Option<String>,
+    /// Case insensitive search
+    #[serde(rename = "-i", default, skip_serializing_if = "is_false")]
+    pub case_insensitive: bool,
+    /// Show line numbers (content mode only)
+    #[serde(rename = "-n", default, skip_serializing_if = "is_false")]
+    pub line_numbers: bool,
+    /// Lines after match (content mode only)
+    #[serde(rename = "-A", skip_serializing_if = "Option::is_none")]
+    pub after_context: Option<u32>,
+    /// Lines before match (content mode only)
+    #[serde(rename = "-B", skip_serializing_if = "Option::is_none")]
+    pub before_context: Option<u32>,
+    /// Lines before and after match (content mode only)
+    #[serde(rename = "-C", skip_serializing_if = "Option::is_none")]
+    pub context: Option<u32>,
+    /// Enable multiline/cross-line matching
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub multiline: bool,
+    /// Limit output to first N results
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub head_limit: Option<u32>,
+}
+
+impl std::fmt::Display for GrepToolParams {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "grep")?;
+
+        // Boolean flags
+        if self.case_insensitive {
+            write!(f, " -i")?;
+        }
+        if self.line_numbers {
+            write!(f, " -n")?;
+        }
+
+        // Context options
+        if let Some(after) = self.after_context {
+            write!(f, " -A {}", after)?;
+        }
+        if let Some(before) = self.before_context {
+            write!(f, " -B {}", before)?;
+        }
+        if let Some(context) = self.context {
+            write!(f, " -C {}", context)?;
+        }
+
+        // Output mode
+        if let Some(mode) = &self.output_mode {
+            match mode {
+                GrepOutputMode::FilesWithMatches => write!(f, " -l")?,
+                GrepOutputMode::Count => write!(f, " -c")?,
+                GrepOutputMode::Content => {} // Default mode
+            }
+        }
+
+        // Head limit
+        if let Some(limit) = self.head_limit {
+            write!(f, " | head -{}", limit)?;
+        }
+
+        // Glob pattern
+        if let Some(glob) = &self.glob {
+            write!(f, " --include=\"{}\"", glob)?;
+        }
+
+        // File type
+        if let Some(file_type) = &self.file_type {
+            write!(f, " --type={}", file_type)?;
+        }
+
+        // Multiline
+        if self.multiline {
+            write!(f, " -P")?; // Perl-compatible regex for multiline
+        }
+
+        // Pattern (escaped if contains special characters)
+        write!(f, " \"{}\"", self.pattern)?;
+
+        // Path
+        if let Some(path) = &self.path {
+            write!(f, " {}", path)?;
+        }
+
+        Ok(())
+    }
+}
+
+#[derive(Deserialize, Serialize, JsonSchema, strum::Display, Debug)]
+#[serde(rename_all = "snake_case")]
+pub enum TodoPriority {
+    High,
+    Medium,
+    Low,
+}
+
+#[derive(Deserialize, Serialize, JsonSchema, Debug)]
+#[serde(rename_all = "snake_case")]
+pub enum TodoStatus {
+    Pending,
+    InProgress,
+    Completed,
+}
+
+#[derive(Deserialize, Serialize, JsonSchema, Debug)]
+pub struct Todo {
+    /// Unique identifier
+    pub id: String,
+    /// Task description
+    pub content: String,
+    /// Priority level of the todo
+    pub priority: TodoPriority,
+    /// Current status of the todo
+    pub status: TodoStatus,
+}
+
+#[derive(Deserialize, JsonSchema, Debug)]
+pub struct TodoWriteToolParams {
+    pub todos: Vec<Todo>,
+}
+
+#[derive(Deserialize, JsonSchema, Debug)]
+pub struct ExitPlanModeToolParams {
+    /// Implementation plan in markdown format
+    pub plan: String,
+}
+
+#[derive(Deserialize, JsonSchema, Debug)]
+pub struct TaskToolParams {
+    /// Short 3-5 word description of task
+    pub description: String,
+    /// Detailed task for agent to perform
+    pub prompt: String,
+}
+
+#[derive(Deserialize, JsonSchema, Debug)]
+pub struct NotebookReadToolParams {
+    /// Absolute path to .ipynb file
+    pub notebook_path: PathBuf,
+    /// Specific cell ID to read
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cell_id: Option<String>,
+}
+
+#[derive(Deserialize, Serialize, JsonSchema, Debug)]
+#[serde(rename_all = "snake_case")]
+pub enum CellType {
+    Code,
+    Markdown,
+}
+
+#[derive(Deserialize, Serialize, JsonSchema, Debug)]
+#[serde(rename_all = "snake_case")]
+pub enum EditMode {
+    Replace,
+    Insert,
+    Delete,
+}
+
+#[derive(Deserialize, JsonSchema, Debug)]
+pub struct NotebookEditToolParams {
+    /// Absolute path to .ipynb file
+    pub notebook_path: PathBuf,
+    /// New cell content
+    pub new_source: String,
+    /// Cell ID to edit
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cell_id: Option<String>,
+    /// Type of cell (code or markdown)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cell_type: Option<CellType>,
+    /// Edit operation mode
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub edit_mode: Option<EditMode>,
+}
+
+#[derive(Deserialize, Serialize, JsonSchema, Debug)]
+pub struct MultiEditItem {
+    /// The text to search for and replace
+    pub old_string: String,
+    /// The replacement text
+    pub new_string: String,
+    /// Whether to replace all occurrences or just the first
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub replace_all: bool,
+}
+
+#[derive(Deserialize, JsonSchema, Debug)]
+pub struct MultiEditToolParams {
+    /// Absolute path to file
+    pub file_path: PathBuf,
+    /// List of edits to apply
+    pub edits: Vec<MultiEditItem>,
+}
+
+fn is_false(v: &bool) -> bool {
+    !*v
+}
+
+#[derive(Deserialize, JsonSchema, Debug)]
+#[serde(rename_all = "snake_case")]
+pub enum GrepOutputMode {
+    Content,
+    FilesWithMatches,
+    Count,
+}
+
+#[derive(Deserialize, JsonSchema, Debug)]
+pub struct WebFetchToolParams {
+    /// Valid URL to fetch
+    #[serde(rename = "url")]
+    pub url: String,
+    /// What to extract from content
+    pub prompt: String,
+}
+
+#[derive(Deserialize, JsonSchema, Debug)]
+pub struct WebSearchToolParams {
+    /// Search query (min 2 chars)
+    pub query: String,
+    /// Only include these domains
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub allowed_domains: Vec<String>,
+    /// Exclude these domains
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub blocked_domains: Vec<String>,
+}
+
+impl std::fmt::Display for WebSearchToolParams {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "\"{}\"", self.query)?;
+
+        if !self.allowed_domains.is_empty() {
+            write!(f, " (allowed: {})", self.allowed_domains.join(", "))?;
+        }
+
+        if !self.blocked_domains.is_empty() {
+            write!(f, " (blocked: {})", self.blocked_domains.join(", "))?;
+        }
+
+        Ok(())
+    }
+}

crates/agent_servers/src/codex.rs

@@ -1,118 +0,0 @@
-use crate::stdio_agent_server::{StdioAgentServer, find_bin_in_path};
-use crate::{AgentServerCommand, AgentServerVersion};
-use anyhow::{Context as _, Result};
-use gpui::{AsyncApp, Entity};
-use project::Project;
-use settings::SettingsStore;
-
-use crate::AllAgentServersSettings;
-
-#[derive(Clone)]
-pub struct Codex;
-
-const ACP_ARG: &str = "acp";
-
-impl StdioAgentServer for Codex {
-    fn name(&self) -> &'static str {
-        "Codex"
-    }
-
-    fn empty_state_headline(&self) -> &'static str {
-        "Welcome to Codex"
-    }
-
-    fn empty_state_message(&self) -> &'static str {
-        "Ask questions, edit files, run commands.\nBe specific for the best results."
-    }
-
-    fn logo(&self) -> ui::IconName {
-        ui::IconName::AiOpenAi
-    }
-
-    async fn command(
-        &self,
-        project: &Entity<Project>,
-        cx: &mut AsyncApp,
-    ) -> Result<AgentServerCommand> {
-        let custom_command = cx.read_global(|settings: &SettingsStore, _| {
-            let settings = settings.get::<AllAgentServersSettings>(None);
-            settings
-                .codex
-                .as_ref()
-                .map(|codex_settings| AgentServerCommand {
-                    path: codex_settings.command.path.clone(),
-                    args: codex_settings
-                        .command
-                        .args
-                        .iter()
-                        .cloned()
-                        .chain(std::iter::once(ACP_ARG.into()))
-                        .collect(),
-                    env: codex_settings.command.env.clone(),
-                })
-        })?;
-
-        if let Some(custom_command) = custom_command {
-            return Ok(custom_command);
-        }
-
-        if let Some(path) = find_bin_in_path("codex", project, cx).await {
-            return Ok(AgentServerCommand {
-                path,
-                args: vec![ACP_ARG.into()],
-                env: None,
-            });
-        }
-
-        todo!()
-        // let (fs, node_runtime) = project.update(cx, |project, _| {
-        //     (project.fs().clone(), project.node_runtime().cloned())
-        // })?;
-        // let node_runtime = node_runtime.context("codex not found on path")?;
-
-        // let directory = ::paths::agent_servers_dir().join("codex");
-        // fs.create_dir(&directory).await?;
-        // node_runtime
-        //     .npm_install_packages(&directory, &[("@google/gemini-cli", "latest")])
-        //     .await?;
-        // let path = directory.join("node_modules/.bin/gemini");
-
-        // Ok(AgentServerCommand {
-        //     path,
-        //     args: vec![ACP_ARG.into()],
-        //     env: None,
-        // })
-    }
-
-    async fn version(&self, command: &AgentServerCommand) -> Result<AgentServerVersion> {
-        let version_fut = util::command::new_smol_command(&command.path)
-            .args(command.args.iter())
-            .arg("--version")
-            .kill_on_drop(true)
-            .output();
-
-        let help_fut = util::command::new_smol_command(&command.path)
-            .args(command.args.iter())
-            .arg("--help")
-            .kill_on_drop(true)
-            .output();
-
-        let (version_output, help_output) = futures::future::join(version_fut, help_fut).await;
-
-        let current_version = String::from_utf8(version_output?.stdout)?;
-        let supported = String::from_utf8(help_output?.stdout)?.contains(ACP_ARG);
-
-        if supported {
-            Ok(AgentServerVersion::Supported)
-        } else {
-            Ok(AgentServerVersion::Unsupported {
-                error_message: format!(
-                    "Your installed version of Codex {} doesn't support the Agentic Coding Protocol (ACP).",
-                    current_version
-                ).into(),
-                upgrade_message: "Upgrade Codex to Latest".into(),
-                upgrade_command: "npm install -g @openai/codex@latest".into(),
-            })
-        }
-    }
-}

crates/agent_servers/src/e2e_tests.rs

@@ -0,0 +1,412 @@
+use std::{path::Path, sync::Arc, time::Duration};
+
+use crate::{AgentServer, AgentServerSettings, AllAgentServersSettings};
+use acp_thread::{
+    AcpThread, AgentThreadEntry, ToolCall, ToolCallConfirmation, ToolCallContent, ToolCallStatus,
+};
+use agentic_coding_protocol as acp;
+use futures::{FutureExt, StreamExt, channel::mpsc, select};
+use gpui::{Entity, TestAppContext};
+use indoc::indoc;
+use project::{FakeFs, Project};
+use serde_json::json;
+use settings::{Settings, SettingsStore};
+use util::path;
+
+pub async fn test_basic(server: impl AgentServer + 'static, cx: &mut TestAppContext) {
+    let fs = init_test(cx).await;
+    let project = Project::test(fs, [], cx).await;
+    let thread = new_test_thread(server, project.clone(), "/private/tmp", cx).await;
+
+    thread
+        .update(cx, |thread, cx| thread.send_raw("Hello from Zed!", cx))
+        .await
+        .unwrap();
+
+    thread.read_with(cx, |thread, _| {
+        assert_eq!(thread.entries().len(), 2);
+        assert!(matches!(
+            thread.entries()[0],
+            AgentThreadEntry::UserMessage(_)
+        ));
+        assert!(matches!(
+            thread.entries()[1],
+            AgentThreadEntry::AssistantMessage(_)
+        ));
+    });
+}
+
+pub async fn test_path_mentions(server: impl AgentServer + 'static, cx: &mut TestAppContext) {
+    let _fs = init_test(cx).await;
+
+    let tempdir = tempfile::tempdir().unwrap();
+    std::fs::write(
+        tempdir.path().join("foo.rs"),
+        indoc! {"
+            fn main() {
+                println!(\"Hello, world!\");
+            }
+        "},
+    )
+    .expect("failed to write file");
+    let project = Project::example([tempdir.path()], &mut cx.to_async()).await;
+    let thread = new_test_thread(server, project.clone(), tempdir.path(), cx).await;
+    thread
+        .update(cx, |thread, cx| {
+            thread.send(
+                acp::SendUserMessageParams {
+                    chunks: vec![
+                        acp::UserMessageChunk::Text {
+                            text: "Read the file ".into(),
+                        },
+                        acp::UserMessageChunk::Path {
+                            path: Path::new("foo.rs").into(),
+                        },
+                        acp::UserMessageChunk::Text {
+                            text: " and tell me what the content of the println! is".into(),
+                        },
+                    ],
+                },
+                cx,
+            )
+        })
+        .await
+        .unwrap();
+
+    thread.read_with(cx, |thread, cx| {
+        assert_eq!(thread.entries().len(), 3);
+        assert!(matches!(
+            thread.entries()[0],
+            AgentThreadEntry::UserMessage(_)
+        ));
+        assert!(matches!(thread.entries()[1], AgentThreadEntry::ToolCall(_)));
+        let AgentThreadEntry::AssistantMessage(assistant_message) = &thread.entries()[2] else {
+            panic!("Expected AssistantMessage")
+        };
+        assert!(
+            assistant_message.to_markdown(cx).contains("Hello, world!"),
+            "unexpected assistant message: {:?}",
+            assistant_message.to_markdown(cx)
+        );
+    });
+}
+
+pub async fn test_tool_call(server: impl AgentServer + 'static, cx: &mut TestAppContext) {
+    let fs = init_test(cx).await;
+    fs.insert_tree(
+        path!("/private/tmp"),
+        json!({"foo": "Lorem ipsum dolor", "bar": "bar", "baz": "baz"}),
+    )
+    .await;
+    let project = Project::test(fs, [path!("/private/tmp").as_ref()], cx).await;
+    let thread = new_test_thread(server, project.clone(), "/private/tmp", cx).await;
+
+    thread
+        .update(cx, |thread, cx| {
+            thread.send_raw(
+                "Read the '/private/tmp/foo' file and tell me what you see.",
+                cx,
+            )
+        })
+        .await
+        .unwrap();
+    thread.read_with(cx, |thread, _cx| {
+        assert!(thread.entries().iter().any(|entry| {
+            matches!(
+                entry,
+                AgentThreadEntry::ToolCall(ToolCall {
+                    status: ToolCallStatus::Allowed { .. },
+                    ..
+                })
+            )
+        }));
+        assert!(
+            thread
+                .entries()
+                .iter()
+                .any(|entry| { matches!(entry, AgentThreadEntry::AssistantMessage(_)) })
+        );
+    });
+}
+
+pub async fn test_tool_call_with_confirmation(
+    server: impl AgentServer + 'static,
+    cx: &mut TestAppContext,
+) {
+    let fs = init_test(cx).await;
+    let project = Project::test(fs, [path!("/private/tmp").as_ref()], cx).await;
+    let thread = new_test_thread(server, project.clone(), "/private/tmp", cx).await;
+    let full_turn = thread.update(cx, |thread, cx| {
+        thread.send_raw(
+            r#"Run `touch hello.txt && echo "Hello, world!" | tee hello.txt`"#,
+            cx,
+        )
+    });
+
+    run_until_first_tool_call(
+        &thread,
+        |entry| {
+            matches!(
+                entry,
+                AgentThreadEntry::ToolCall(ToolCall {
+                    status: ToolCallStatus::WaitingForConfirmation { .. },
+                    ..
+                })
+            )
+        },
+        cx,
+    )
+    .await;
+
+    let tool_call_id = thread.read_with(cx, |thread, _cx| {
+        let AgentThreadEntry::ToolCall(ToolCall {
+            id,
+            status:
+                ToolCallStatus::WaitingForConfirmation {
+                    confirmation: ToolCallConfirmation::Execute { root_command, .. },
+                    ..
+                },
+            ..
+        }) = &thread
+            .entries()
+            .iter()
+            .find(|entry| matches!(entry, AgentThreadEntry::ToolCall(_)))
+            .unwrap()
+        else {
+            panic!();
+        };
+
+        assert!(root_command.contains("touch"));
+
+        *id
+    });
+
+    thread.update(cx, |thread, cx| {
+        thread.authorize_tool_call(tool_call_id, acp::ToolCallConfirmationOutcome::Allow, cx);
+
+        assert!(thread.entries().iter().any(|entry| matches!(
+            entry,
+            AgentThreadEntry::ToolCall(ToolCall {
+                status: ToolCallStatus::Allowed { .. },
+                ..
+            })
+        )));
+    });
+
+    full_turn.await.unwrap();
+
+    thread.read_with(cx, |thread, cx| {
+        let AgentThreadEntry::ToolCall(ToolCall {
+            content: Some(ToolCallContent::Markdown { markdown }),
+            status: ToolCallStatus::Allowed { .. },
+            ..
+        }) = thread
+            .entries()
+            .iter()
+            .find(|entry| matches!(entry, AgentThreadEntry::ToolCall(_)))
+            .unwrap()
+        else {
+            panic!();
+        };
+
+        markdown.read_with(cx, |md, _cx| {
+            assert!(
+                md.source().contains("Hello"),
+                r#"Expected '{}' to contain "Hello""#,
+                md.source()
+            );
+        });
+    });
+}
+
+pub async fn test_cancel(server: impl AgentServer + 'static, cx: &mut TestAppContext) {
+    let fs = init_test(cx).await;
+
+    let project = Project::test(fs, [path!("/private/tmp").as_ref()], cx).await;
+    let thread = new_test_thread(server, project.clone(), "/private/tmp", cx).await;
+    let full_turn = thread.update(cx, |thread, cx| {
+        thread.send_raw(
+            r#"Run `touch hello.txt && echo "Hello, world!" >> hello.txt`"#,
+            cx,
+        )
+    });
+
+    let first_tool_call_ix = run_until_first_tool_call(
+        &thread,
+        |entry| {
+            matches!(
+                entry,
+                AgentThreadEntry::ToolCall(ToolCall {
+                    status: ToolCallStatus::WaitingForConfirmation { .. },
+                    ..
+                })
+            )
+        },
+        cx,
+    )
+    .await;
+
+    thread.read_with(cx, |thread, _cx| {
+        let AgentThreadEntry::ToolCall(ToolCall {
+            id,
+            status:
+                ToolCallStatus::WaitingForConfirmation {
+                    confirmation: ToolCallConfirmation::Execute { root_command, .. },
+                    ..
+                },
+            ..
+        }) = &thread.entries()[first_tool_call_ix]
+        else {
+            panic!("{:?}", thread.entries()[1]);
+        };
+
+        assert!(root_command.contains("touch"));
+
+        *id
+    });
+
+    thread
+        .update(cx, |thread, cx| thread.cancel(cx))
+        .await
+        .unwrap();
+    full_turn.await.unwrap();
+    thread.read_with(cx, |thread, _| {
+        let AgentThreadEntry::ToolCall(ToolCall {
+            status: ToolCallStatus::Canceled,
+            ..
+        }) = &thread.entries()[first_tool_call_ix]
+        else {
+            panic!();
+        };
+    });
+
+    thread
+        .update(cx, |thread, cx| {
+            thread.send_raw(r#"Stop running and say goodbye to me."#, cx)
+        })
+        .await
+        .unwrap();
+    thread.read_with(cx, |thread, _| {
+        assert!(matches!(
+            &thread.entries().last().unwrap(),
+            AgentThreadEntry::AssistantMessage(..),
+        ))
+    });
+}
+
+#[macro_export]
+macro_rules! common_e2e_tests {
+    ($server:expr) => {
+        mod common_e2e {
+            use super::*;
+
+            #[::gpui::test]
+            #[cfg_attr(not(feature = "e2e"), ignore)]
+            async fn basic(cx: &mut ::gpui::TestAppContext) {
+                $crate::e2e_tests::test_basic($server, cx).await;
+            }
+
+            #[::gpui::test]
+            #[cfg_attr(not(feature = "e2e"), ignore)]
+            async fn path_mentions(cx: &mut ::gpui::TestAppContext) {
+                $crate::e2e_tests::test_path_mentions($server, cx).await;
+            }
+
+            #[::gpui::test]
+            #[cfg_attr(not(feature = "e2e"), ignore)]
+            async fn tool_call(cx: &mut ::gpui::TestAppContext) {
+                $crate::e2e_tests::test_tool_call($server, cx).await;
+            }
+
+            #[::gpui::test]
+            #[cfg_attr(not(feature = "e2e"), ignore)]
+            async fn tool_call_with_confirmation(cx: &mut ::gpui::TestAppContext) {
+                $crate::e2e_tests::test_tool_call_with_confirmation($server, cx).await;
+            }
+
+            #[::gpui::test]
+            #[cfg_attr(not(feature = "e2e"), ignore)]
+            async fn cancel(cx: &mut ::gpui::TestAppContext) {
+                $crate::e2e_tests::test_cancel($server, cx).await;
+            }
+        }
+    };
+}
+
+// Helpers
+
+pub async fn init_test(cx: &mut TestAppContext) -> Arc<FakeFs> {
+    env_logger::try_init().ok();
+
+    cx.update(|cx| {
+        let settings_store = SettingsStore::test(cx);
+        cx.set_global(settings_store);
+        Project::init_settings(cx);
+        language::init(cx);
+        crate::settings::init(cx);
+
+        crate::AllAgentServersSettings::override_global(
+            AllAgentServersSettings {
+                claude: Some(AgentServerSettings {
+                    command: crate::claude::tests::local_command(),
+                }),
+                gemini: Some(AgentServerSettings {
+                    command: crate::gemini::tests::local_command(),
+                }),
+            },
+            cx,
+        );
+    });
+
+    cx.executor().allow_parking();
+
+    FakeFs::new(cx.executor())
+}
+
+pub async fn new_test_thread(
+    server: impl AgentServer + 'static,
+    project: Entity<Project>,
+    current_dir: impl AsRef<Path>,
+    cx: &mut TestAppContext,
+) -> Entity<AcpThread> {
+    let thread = cx
+        .update(|cx| server.new_thread(current_dir.as_ref(), &project, cx))
+        .await
+        .unwrap();
+
+    thread
+        .update(cx, |thread, _| thread.initialize())
+        .await
+        .unwrap();
+    thread
+}
+
+pub async fn run_until_first_tool_call(
+    thread: &Entity<AcpThread>,
+    wait_until: impl Fn(&AgentThreadEntry) -> bool + 'static,
+    cx: &mut TestAppContext,
+) -> usize {
+    let (mut tx, mut rx) = mpsc::channel::<usize>(1);
+
+    let subscription = cx.update(|cx| {
+        cx.subscribe(thread, move |thread, _, cx| {
+            for (ix, entry) in thread.read(cx).entries().iter().enumerate() {
+                if wait_until(entry) {
+                    return tx.try_send(ix).unwrap();
+                }
+            }
+        })
+    });
+
+    select! {
+        // We have to use a smol timer here because
+        // cx.background_executor().timer isn't real in the test context
+        _ = futures::FutureExt::fuse(smol::Timer::after(Duration::from_secs(20))) => {
+            panic!("Timeout waiting for tool call")
+        }
+        ix = rx.next().fuse() => {
+            drop(subscription);
+            ix.unwrap()
+        }
+    }
+}

crates/agent_servers/src/gemini.rs

@@ -0,0 +1,123 @@
+use crate::stdio_agent_server::StdioAgentServer;
+use crate::{AgentServerCommand, AgentServerVersion};
+use anyhow::{Context as _, Result};
+use gpui::{AsyncApp, Entity};
+use project::Project;
+use settings::SettingsStore;
+
+use crate::AllAgentServersSettings;
+
+#[derive(Clone)]
+pub struct Gemini;
+
+const ACP_ARG: &str = "--experimental-acp";
+
+impl StdioAgentServer for Gemini {
+    fn name(&self) -> &'static str {
+        "Gemini"
+    }
+
+    fn empty_state_headline(&self) -> &'static str {
+        "Welcome to Gemini"
+    }
+
+    fn empty_state_message(&self) -> &'static str {
+        "Ask questions, edit files, run commands.\nBe specific for the best results."
+    }
+
+    fn supports_always_allow(&self) -> bool {
+        true
+    }
+
+    fn logo(&self) -> ui::IconName {
+        ui::IconName::AiGemini
+    }
+
+    async fn command(
+        &self,
+        project: &Entity<Project>,
+        cx: &mut AsyncApp,
+    ) -> Result<AgentServerCommand> {
+        let settings = cx.read_global(|settings: &SettingsStore, _| {
+            settings.get::<AllAgentServersSettings>(None).gemini.clone()
+        })?;
+
+        if let Some(command) =
+            AgentServerCommand::resolve("gemini", &[ACP_ARG], settings, &project, cx).await
+        {
+            return Ok(command);
+        };
+
+        let (fs, node_runtime) = project.update(cx, |project, _| {
+            (project.fs().clone(), project.node_runtime().cloned())
+        })?;
+        let node_runtime = node_runtime.context("gemini not found on path")?;
+
+        let directory = ::paths::agent_servers_dir().join("gemini");
+        fs.create_dir(&directory).await?;
+        node_runtime
+            .npm_install_packages(&directory, &[("@google/gemini-cli", "latest")])
+            .await?;
+        let path = directory.join("node_modules/.bin/gemini");
+
+        Ok(AgentServerCommand {
+            path,
+            args: vec![ACP_ARG.into()],
+            env: None,
+        })
+    }
+
+    async fn version(&self, command: &AgentServerCommand) -> Result<AgentServerVersion> {
+        let version_fut = util::command::new_smol_command(&command.path)
+            .args(command.args.iter())
+            .arg("--version")
+            .kill_on_drop(true)
+            .output();
+
+        let help_fut = util::command::new_smol_command(&command.path)
+            .args(command.args.iter())
+            .arg("--help")
+            .kill_on_drop(true)
+            .output();
+
+        let (version_output, help_output) = futures::future::join(version_fut, help_fut).await;
+
+        let current_version = String::from_utf8(version_output?.stdout)?;
+        let supported = String::from_utf8(help_output?.stdout)?.contains(ACP_ARG);
+
+        if supported {
+            Ok(AgentServerVersion::Supported)
+        } else {
+            Ok(AgentServerVersion::Unsupported {
+                error_message: format!(
+                    "Your installed version of Gemini {} doesn't support the Agentic Coding Protocol (ACP).",
+                    current_version
+                ).into(),
+                upgrade_message: "Upgrade Gemini to Latest".into(),
+                upgrade_command: "npm install -g @google/gemini-cli@latest".into(),
+            })
+        }
+    }
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+    use super::*;
+    use crate::AgentServerCommand;
+    use std::path::Path;
+
+    crate::common_e2e_tests!(Gemini);
+
+    pub fn local_command() -> AgentServerCommand {
+        let cli_path = Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../../gemini-cli/packages/cli")
+            .to_string_lossy()
+            .to_string();
+
+        AgentServerCommand {
+            path: "node".into(),
+            args: vec![cli_path, ACP_ARG.into()],
+            env: None,
+        }
+    }
+}

crates/agent_servers/src/settings.rs

@@ -0,0 +1,42 @@
+use crate::AgentServerCommand;
+use anyhow::Result;
+use gpui::App;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use settings::{Settings, SettingsSources};
+
+pub fn init(cx: &mut App) {
+    AllAgentServersSettings::register(cx);
+}
+
+#[derive(Default, Deserialize, Serialize, Clone, JsonSchema, Debug)]
+pub struct AllAgentServersSettings {
+    pub gemini: Option<AgentServerSettings>,
+    pub claude: Option<AgentServerSettings>,
+}
+
+#[derive(Deserialize, Serialize, Clone, JsonSchema, Debug)]
+pub struct AgentServerSettings {
+    #[serde(flatten)]
+    pub command: AgentServerCommand,
+}
+
+impl settings::Settings for AllAgentServersSettings {
+    const KEY: Option<&'static str> = Some("agent_servers");
+
+    type FileContent = Self;
+
+    fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> Result<Self> {
+        let mut settings = AllAgentServersSettings::default();
+
+        for value in sources.defaults_and_customizations() {
+            if value.gemini.is_some() {
+                settings.gemini = value.gemini.clone();
+            }
+        }
+
+        Ok(settings)
+    }
+
+    fn import_from_vscode(_vscode: &settings::VsCodeSettings, _current: &mut Self::FileContent) {}
+}

crates/agent_servers/src/stdio_agent_server.rs

@@ -0,0 +1,119 @@
+use crate::{AgentServer, AgentServerCommand, AgentServerVersion};
+use acp_thread::{AcpClientDelegate, AcpThread, LoadError};
+use agentic_coding_protocol as acp;
+use anyhow::{Result, anyhow};
+use gpui::{App, AsyncApp, Entity, Task, prelude::*};
+use project::Project;
+use std::path::Path;
+use util::ResultExt;
+
+pub trait StdioAgentServer: Send + Clone {
+    fn logo(&self) -> ui::IconName;
+    fn name(&self) -> &'static str;
+    fn empty_state_headline(&self) -> &'static str;
+    fn empty_state_message(&self) -> &'static str;
+    fn supports_always_allow(&self) -> bool;
+
+    fn command(
+        &self,
+        project: &Entity<Project>,
+        cx: &mut AsyncApp,
+    ) -> impl Future<Output = Result<AgentServerCommand>>;
+
+    fn version(
+        &self,
+        command: &AgentServerCommand,
+    ) -> impl Future<Output = Result<AgentServerVersion>> + Send;
+}
+
+impl<T: StdioAgentServer + 'static> AgentServer for T {
+    fn name(&self) -> &'static str {
+        self.name()
+    }
+
+    fn empty_state_headline(&self) -> &'static str {
+        self.empty_state_headline()
+    }
+
+    fn empty_state_message(&self) -> &'static str {
+        self.empty_state_message()
+    }
+
+    fn logo(&self) -> ui::IconName {
+        self.logo()
+    }
+
+    fn supports_always_allow(&self) -> bool {
+        self.supports_always_allow()
+    }
+
+    fn new_thread(
+        &self,
+        root_dir: &Path,
+        project: &Entity<Project>,
+        cx: &mut App,
+    ) -> Task<Result<Entity<AcpThread>>> {
+        let root_dir = root_dir.to_path_buf();
+        let project = project.clone();
+        let this = self.clone();
+        let title = self.name().into();
+
+        cx.spawn(async move |cx| {
+            let command = this.command(&project, cx).await?;
+
+            let mut child = util::command::new_smol_command(&command.path)
+                .args(command.args.iter())
+                .current_dir(root_dir)
+                .stdin(std::process::Stdio::piped())
+                .stdout(std::process::Stdio::piped())
+                .stderr(std::process::Stdio::inherit())
+                .kill_on_drop(true)
+                .spawn()?;
+
+            let stdin = child.stdin.take().unwrap();
+            let stdout = child.stdout.take().unwrap();
+
+            cx.new(|cx| {
+                let foreground_executor = cx.foreground_executor().clone();
+
+                let (connection, io_fut) = acp::AgentConnection::connect_to_agent(
+                    AcpClientDelegate::new(cx.entity().downgrade(), cx.to_async()),
+                    stdin,
+                    stdout,
+                    move |fut| foreground_executor.spawn(fut).detach(),
+                );
+
+                let io_task = cx.background_spawn(async move {
+                    io_fut.await.log_err();
+                });
+
+                let child_status = cx.background_spawn(async move {
+                    let result = match child.status().await {
+                        Err(e) => Err(anyhow!(e)),
+                        Ok(result) if result.success() => Ok(()),
+                        Ok(result) => {
+                            if let Some(AgentServerVersion::Unsupported {
+                                error_message,
+                                upgrade_message,
+                                upgrade_command,
+                            }) = this.version(&command).await.log_err()
+                            {
+                                Err(anyhow!(LoadError::Unsupported {
+                                    error_message,
+                                    upgrade_message,
+                                    upgrade_command
+                                }))
+                            } else {
+                                Err(anyhow!(LoadError::Exited(result.code().unwrap_or(-127))))
+                            }
+                        }
+                    };
+                    drop(io_task);
+                    result
+                });
+
+                AcpThread::new(connection, title, Some(child_status), project.clone(), cx)
+            })
+        })
+    }
+}

crates/agent_settings/src/agent_settings.rs

@@ -69,6 +69,7 @@ pub struct AgentSettings {
     pub enable_feedback: bool,
     pub expand_edit_card: bool,
     pub expand_terminal_card: bool,
+    pub use_modifier_to_send: bool,
 }
 
 impl AgentSettings {
@@ -174,6 +175,10 @@ impl AgentSettingsContent {
         self.single_file_review = Some(allow);
     }
 
+    pub fn set_use_modifier_to_send(&mut self, always_use: bool) {
+        self.use_modifier_to_send = Some(always_use);
+    }
+
     pub fn set_profile(&mut self, profile_id: AgentProfileId) {
         self.default_profile = Some(profile_id);
     }
@@ -301,6 +306,10 @@ pub struct AgentSettingsContent {
     ///
     /// Default: true
     expand_terminal_card: Option<bool>,
+    /// Whether to always use cmd-enter (or ctrl-enter on Linux) to send messages in the agent panel.
+    ///
+    /// Default: false
+    use_modifier_to_send: Option<bool>,
 }
 
 #[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Default)]
@@ -456,6 +465,10 @@ impl Settings for AgentSettings {
                 &mut settings.expand_terminal_card,
                 value.expand_terminal_card,
             );
+            merge(
+                &mut settings.use_modifier_to_send,
+                value.use_modifier_to_send,
+            );
 
             settings
                 .model_parameters

crates/agent_ui/Cargo.toml

@@ -16,11 +16,12 @@ doctest = false
 test-support = ["gpui/test-support", "language/test-support"]
 
 [dependencies]
-acp.workspace = true
+acp_thread.workspace = true
 agent.workspace = true
 agentic-coding-protocol.workspace = true
 agent_settings.workspace = true
 agent_servers.workspace = true
+ai_onboarding.workspace = true
 anyhow.workspace = true
 assistant_context.workspace = true
 assistant_slash_command.workspace = true

crates/agent_ui/src/acp/thread_view.rs

@@ -1,3 +1,4 @@
+use agent_servers::AgentServer;
 use std::cell::RefCell;
 use std::collections::BTreeMap;
 use std::path::Path;
@@ -35,7 +36,7 @@ use util::ResultExt;
 use workspace::{CollaboratorId, Workspace};
 use zed_actions::agent::{Chat, NextHistoryMessage, PreviousHistoryMessage};
 
-use ::acp::{
+use ::acp_thread::{
     AcpThread, AcpThreadEvent, AgentThreadEntry, AssistantMessage, AssistantMessageChunk, Diff,
     LoadError, MentionPath, ThreadStatus, ToolCall, ToolCallConfirmation, ToolCallContent,
     ToolCallId, ToolCallStatus,
@@ -49,6 +50,7 @@ use crate::{AgentDiffPane, Follow, KeepAll, OpenAgentDiff, RejectAll};
 const RESPONSE_PADDING_X: Pixels = px(19.);
 
 pub struct AcpThreadView {
+    agent: Rc<dyn AgentServer>,
     workspace: WeakEntity<Workspace>,
     project: Entity<Project>,
     thread_state: ThreadState,
@@ -80,8 +82,15 @@ enum ThreadState {
     },
 }
 
+struct AlwaysAllowOption {
+    id: &'static str,
+    label: SharedString,
+    outcome: acp::ToolCallConfirmationOutcome,
+}
+
 impl AcpThreadView {
     pub fn new(
+        agent: Rc<dyn AgentServer>,
         workspace: WeakEntity<Workspace>,
         project: Entity<Project>,
         message_history: Rc<RefCell<MessageHistory<acp::SendUserMessageParams>>>,
@@ -158,9 +167,10 @@ impl AcpThreadView {
         );
 
         Self {
+            agent: agent.clone(),
             workspace: workspace.clone(),
             project: project.clone(),
-            thread_state: Self::initial_state(workspace, project, window, cx),
+            thread_state: Self::initial_state(agent, workspace, project, window, cx),
             message_editor,
             message_set_from_history: false,
             _message_editor_subscription: message_editor_subscription,
@@ -177,6 +187,7 @@ impl AcpThreadView {
     }
 
     fn initial_state(
+        agent: Rc<dyn AgentServer>,
         workspace: WeakEntity<Workspace>,
         project: Entity<Project>,
         window: &mut Window,
@@ -189,9 +200,9 @@ impl AcpThreadView {
             .map(|worktree| worktree.read(cx).abs_path())
             .unwrap_or_else(|| paths::home_dir().as_path().into());
 
+        let task = agent.new_thread(&root_dir, &project, cx);
         let load_task = cx.spawn_in(window, async move |this, cx| {
-            let thread = match AcpThread::spawn(agent_servers::Gemini, &root_dir, project, cx).await
-            {
+            let thread = match task.await {
                 Ok(thread) => thread,
                 Err(err) => {
                     this.update(cx, |this, cx| {
@@ -410,6 +421,33 @@ impl AcpThreadView {
         );
     }
 
+    fn open_agent_diff(&mut self, _: &OpenAgentDiff, window: &mut Window, cx: &mut Context<Self>) {
+        if let Some(thread) = self.thread() {
+            AgentDiffPane::deploy(thread.clone(), self.workspace.clone(), window, cx).log_err();
+        }
+    }
+
+    fn open_edited_buffer(
+        &mut self,
+        buffer: &Entity<Buffer>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(thread) = self.thread() else {
+            return;
+        };
+
+        let Some(diff) =
+            AgentDiffPane::deploy(thread.clone(), self.workspace.clone(), window, cx).log_err()
+        else {
+            return;
+        };
+
+        diff.update(cx, |diff, cx| {
+            diff.move_to_path(PathKey::for_buffer(&buffer, cx), window, cx)
+        })
+    }
+
     fn set_draft_message(
         message_editor: Entity<Editor>,
         mention_set: Arc<Mutex<MentionSet>>,
@@ -485,33 +523,6 @@ impl AcpThreadView {
         true
     }
 
-    fn open_agent_diff(&mut self, _: &OpenAgentDiff, window: &mut Window, cx: &mut Context<Self>) {
-        if let Some(thread) = self.thread() {
-            AgentDiffPane::deploy(thread.clone(), self.workspace.clone(), window, cx).log_err();
-        }
-    }
-
-    fn open_edited_buffer(
-        &mut self,
-        buffer: &Entity<Buffer>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        let Some(thread) = self.thread() else {
-            return;
-        };
-
-        let Some(diff) =
-            AgentDiffPane::deploy(thread.clone(), self.workspace.clone(), window, cx).log_err()
-        else {
-            return;
-        };
-
-        diff.update(cx, |diff, cx| {
-            diff.move_to_path(PathKey::for_buffer(&buffer, cx), window, cx)
-        })
-    }
-
     fn handle_thread_event(
         &mut self,
         thread: &Entity<AcpThread>,
@@ -608,6 +619,7 @@ impl AcpThreadView {
         let authenticate = thread.read(cx).authenticate();
         self.auth_task = Some(cx.spawn_in(window, {
             let project = self.project.clone();
+            let agent = self.agent.clone();
             async move |this, cx| {
                 let result = authenticate.await;
 
@@ -617,8 +629,13 @@ impl AcpThreadView {
                             Markdown::new(format!("Error: {err}").into(), None, None, cx)
                         }))
                     } else {
-                        this.thread_state =
-                            Self::initial_state(this.workspace.clone(), project.clone(), window, cx)
+                        this.thread_state = Self::initial_state(
+                            agent,
+                            this.workspace.clone(),
+                            project.clone(),
+                            window,
+                            cx,
+                        )
                     }
                     this.auth_task.take()
                 })
@@ -1047,14 +1064,6 @@ impl AcpThreadView {
     ) -> AnyElement {
         let confirmation_container = v_flex().mt_1().py_1p5();
 
-        let button_container = h_flex()
-            .pt_1p5()
-            .px_1p5()
-            .gap_1()
-            .justify_end()
-            .border_t_1()
-            .border_color(self.tool_card_border_color(cx));
-
         match confirmation {
             ToolCallConfirmation::Edit { description } => confirmation_container
                 .child(
@@ -1068,60 +1077,15 @@ impl AcpThreadView {
                         })),
                 )
                 .children(content.map(|content| self.render_tool_call_content(content, window, cx)))
-                .child(
-                    button_container
-                        .child(
-                            Button::new(("always_allow", tool_call_id.0), "Always Allow Edits")
-                                .icon(IconName::CheckDouble)
-                                .icon_position(IconPosition::Start)
-                                .icon_size(IconSize::XSmall)
-                                .icon_color(Color::Success)
-                                .on_click(cx.listener({
-                                    let id = tool_call_id;
-                                    move |this, _, _, cx| {
-                                        this.authorize_tool_call(
-                                            id,
-                                            acp::ToolCallConfirmationOutcome::AlwaysAllow,
-                                            cx,
-                                        );
-                                    }
-                                })),
-                        )
-                        .child(
-                            Button::new(("allow", tool_call_id.0), "Allow")
-                                .icon(IconName::Check)
-                                .icon_position(IconPosition::Start)
-                                .icon_size(IconSize::XSmall)
-                                .icon_color(Color::Success)
-                                .on_click(cx.listener({
-                                    let id = tool_call_id;
-                                    move |this, _, _, cx| {
-                                        this.authorize_tool_call(
-                                            id,
-                                            acp::ToolCallConfirmationOutcome::Allow,
-                                            cx,
-                                        );
-                                    }
-                                })),
-                        )
-                        .child(
-                            Button::new(("reject", tool_call_id.0), "Reject")
-                                .icon(IconName::X)
-                                .icon_position(IconPosition::Start)
-                                .icon_size(IconSize::XSmall)
-                                .icon_color(Color::Error)
-                                .on_click(cx.listener({
-                                    let id = tool_call_id;
-                                    move |this, _, _, cx| {
-                                        this.authorize_tool_call(
-                                            id,
-                                            acp::ToolCallConfirmationOutcome::Reject,
-                                            cx,
-                                        );
-                                    }
-                                })),
-                        ),
-                )
+                .child(self.render_confirmation_buttons(
+                    &[AlwaysAllowOption {
+                        id: "always_allow",
+                        label: "Always Allow Edits".into(),
+                        outcome: acp::ToolCallConfirmationOutcome::AlwaysAllow,
+                    }],
+                    tool_call_id,
+                    cx,
+                ))
                 .into_any(),
             ToolCallConfirmation::Execute {
                 command,
@@ -1140,66 +1104,15 @@ impl AcpThreadView {
                     }),
                 ))
                 .children(content.map(|content| self.render_tool_call_content(content, window, cx)))
-                .child(
-                    button_container
-                        .child(
-                            Button::new(
-                                ("always_allow", tool_call_id.0),
-                                format!("Always Allow {root_command}"),
-                            )
-                            .icon(IconName::CheckDouble)
-                            .icon_position(IconPosition::Start)
-                            .icon_size(IconSize::XSmall)
-                            .icon_color(Color::Success)
-                            .label_size(LabelSize::Small)
-                            .on_click(cx.listener({
-                                let id = tool_call_id;
-                                move |this, _, _, cx| {
-                                    this.authorize_tool_call(
-                                        id,
-                                        acp::ToolCallConfirmationOutcome::AlwaysAllow,
-                                        cx,
-                                    );
-                                }
-                            })),
-                        )
-                        .child(
-                            Button::new(("allow", tool_call_id.0), "Allow")
-                                .icon(IconName::Check)
-                                .icon_position(IconPosition::Start)
-                                .icon_size(IconSize::XSmall)
-                                .icon_color(Color::Success)
-                                .label_size(LabelSize::Small)
-                                .on_click(cx.listener({
-                                    let id = tool_call_id;
-                                    move |this, _, _, cx| {
-                                        this.authorize_tool_call(
-                                            id,
-                                            acp::ToolCallConfirmationOutcome::Allow,
-                                            cx,
-                                        );
-                                    }
-                                })),
-                        )
-                        .child(
-                            Button::new(("reject", tool_call_id.0), "Reject")
-                                .icon(IconName::X)
-                                .icon_position(IconPosition::Start)
-                                .icon_size(IconSize::XSmall)
-                                .icon_color(Color::Error)
-                                .label_size(LabelSize::Small)
-                                .on_click(cx.listener({
-                                    let id = tool_call_id;
-                                    move |this, _, _, cx| {
-                                        this.authorize_tool_call(
-                                            id,
-                                            acp::ToolCallConfirmationOutcome::Reject,
-                                            cx,
-                                        );
-                                    }
-                                })),
-                        ),
-                )
+                .child(self.render_confirmation_buttons(
+                    &[AlwaysAllowOption {
+                        id: "always_allow",
+                        label: format!("Always Allow {root_command}").into(),
+                        outcome: acp::ToolCallConfirmationOutcome::AlwaysAllow,
+                    }],
+                    tool_call_id,
+                    cx,
+                ))
                 .into_any(),
             ToolCallConfirmation::Mcp {
                 server_name,
@@ -1220,87 +1133,22 @@ impl AcpThreadView {
                         })),
                 )
                 .children(content.map(|content| self.render_tool_call_content(content, window, cx)))
-                .child(
-                    button_container
-                        .child(
-                            Button::new(
-                                ("always_allow_server", tool_call_id.0),
-                                format!("Always Allow {server_name}"),
-                            )
-                            .icon(IconName::CheckDouble)
-                            .icon_position(IconPosition::Start)
-                            .icon_size(IconSize::XSmall)
-                            .icon_color(Color::Success)
-                            .label_size(LabelSize::Small)
-                            .on_click(cx.listener({
-                                let id = tool_call_id;
-                                move |this, _, _, cx| {
-                                    this.authorize_tool_call(
-                                        id,
-                                        acp::ToolCallConfirmationOutcome::AlwaysAllowMcpServer,
-                                        cx,
-                                    );
-                                }
-                            })),
-                        )
-                        .child(
-                            Button::new(
-                                ("always_allow_tool", tool_call_id.0),
-                                format!("Always Allow {tool_display_name}"),
-                            )
-                            .icon(IconName::CheckDouble)
-                            .icon_position(IconPosition::Start)
-                            .icon_size(IconSize::XSmall)
-                            .icon_color(Color::Success)
-                            .label_size(LabelSize::Small)
-                            .on_click(cx.listener({
-                                let id = tool_call_id;
-                                move |this, _, _, cx| {
-                                    this.authorize_tool_call(
-                                        id,
-                                        acp::ToolCallConfirmationOutcome::AlwaysAllowTool,
-                                        cx,
-                                    );
-                                }
-                            })),
-                        )
-                        .child(
-                            Button::new(("allow", tool_call_id.0), "Allow")
-                                .icon(IconName::Check)
-                                .icon_position(IconPosition::Start)
-                                .icon_size(IconSize::XSmall)
-                                .icon_color(Color::Success)
-                                .label_size(LabelSize::Small)
-                                .on_click(cx.listener({
-                                    let id = tool_call_id;
-                                    move |this, _, _, cx| {
-                                        this.authorize_tool_call(
-                                            id,
-                                            acp::ToolCallConfirmationOutcome::Allow,
-                                            cx,
-                                        );
-                                    }
-                                })),
-                        )
-                        .child(
-                            Button::new(("reject", tool_call_id.0), "Reject")
-                                .icon(IconName::X)
-                                .icon_position(IconPosition::Start)
-                                .icon_size(IconSize::XSmall)
-                                .icon_color(Color::Error)
-                                .label_size(LabelSize::Small)
-                                .on_click(cx.listener({
-                                    let id = tool_call_id;
-                                    move |this, _, _, cx| {
-                                        this.authorize_tool_call(
-                                            id,
-                                            acp::ToolCallConfirmationOutcome::Reject,
-                                            cx,
-                                        );
-                                    }
-                                })),
-                        ),
-                )
+                .child(self.render_confirmation_buttons(
+                    &[
+                        AlwaysAllowOption {
+                            id: "always_allow_server",
+                            label: format!("Always Allow {server_name}").into(),
+                            outcome: acp::ToolCallConfirmationOutcome::AlwaysAllowMcpServer,
+                        },
+                        AlwaysAllowOption {
+                            id: "always_allow_tool",
+                            label: format!("Always Allow {tool_display_name}").into(),
+                            outcome: acp::ToolCallConfirmationOutcome::AlwaysAllowTool,
+                        },
+                    ],
+                    tool_call_id,
+                    cx,
+                ))
                 .into_any(),
             ToolCallConfirmation::Fetch { description, urls } => confirmation_container
                 .child(
@@ -1328,63 +1176,15 @@ impl AcpThreadView {
                         })),
                 )
                 .children(content.map(|content| self.render_tool_call_content(content, window, cx)))
-                .child(
-                    button_container
-                        .child(
-                            Button::new(("always_allow", tool_call_id.0), "Always Allow")
-                                .icon(IconName::CheckDouble)
-                                .icon_position(IconPosition::Start)
-                                .icon_size(IconSize::XSmall)
-                                .icon_color(Color::Success)
-                                .label_size(LabelSize::Small)
-                                .on_click(cx.listener({
-                                    let id = tool_call_id;
-                                    move |this, _, _, cx| {
-                                        this.authorize_tool_call(
-                                            id,
-                                            acp::ToolCallConfirmationOutcome::AlwaysAllow,
-                                            cx,
-                                        );
-                                    }
-                                })),
-                        )
-                        .child(
-                            Button::new(("allow", tool_call_id.0), "Allow")
-                                .icon(IconName::Check)
-                                .icon_position(IconPosition::Start)
-                                .icon_size(IconSize::XSmall)
-                                .icon_color(Color::Success)
-                                .label_size(LabelSize::Small)
-                                .on_click(cx.listener({
-                                    let id = tool_call_id;
-                                    move |this, _, _, cx| {
-                                        this.authorize_tool_call(
-                                            id,
-                                            acp::ToolCallConfirmationOutcome::Allow,
-                                            cx,
-                                        );
-                                    }
-                                })),
-                        )
-                        .child(
-                            Button::new(("reject", tool_call_id.0), "Reject")
-                                .icon(IconName::X)
-                                .icon_position(IconPosition::Start)
-                                .icon_size(IconSize::XSmall)
-                                .icon_color(Color::Error)
-                                .label_size(LabelSize::Small)
-                                .on_click(cx.listener({
-                                    let id = tool_call_id;
-                                    move |this, _, _, cx| {
-                                        this.authorize_tool_call(
-                                            id,
-                                            acp::ToolCallConfirmationOutcome::Reject,
-                                            cx,
-                                        );
-                                    }
-                                })),
-                        ),
-                )
+                .child(self.render_confirmation_buttons(
+                    &[AlwaysAllowOption {
+                        id: "always_allow",
+                        label: "Always Allow".into(),
+                        outcome: acp::ToolCallConfirmationOutcome::AlwaysAllow,
+                    }],
+                    tool_call_id,
+                    cx,
+                ))
                 .into_any(),
             ToolCallConfirmation::Other { description } => confirmation_container
                 .child(v_flex().px_2().pb_1p5().child(self.render_markdown(
@@ -1392,67 +1192,87 @@ impl AcpThreadView {
                     default_markdown_style(false, window, cx),
                 )))
                 .children(content.map(|content| self.render_tool_call_content(content, window, cx)))
-                .child(
-                    button_container
-                        .child(
-                            Button::new(("always_allow", tool_call_id.0), "Always Allow")
-                                .icon(IconName::CheckDouble)
-                                .icon_position(IconPosition::Start)
-                                .icon_size(IconSize::XSmall)
-                                .icon_color(Color::Success)
-                                .label_size(LabelSize::Small)
-                                .on_click(cx.listener({
-                                    let id = tool_call_id;
-                                    move |this, _, _, cx| {
-                                        this.authorize_tool_call(
-                                            id,
-                                            acp::ToolCallConfirmationOutcome::AlwaysAllow,
-                                            cx,
-                                        );
-                                    }
-                                })),
-                        )
-                        .child(
-                            Button::new(("allow", tool_call_id.0), "Allow")
-                                .icon(IconName::Check)
-                                .icon_position(IconPosition::Start)
-                                .icon_size(IconSize::XSmall)
-                                .icon_color(Color::Success)
-                                .label_size(LabelSize::Small)
-                                .on_click(cx.listener({
-                                    let id = tool_call_id;
-                                    move |this, _, _, cx| {
-                                        this.authorize_tool_call(
-                                            id,
-                                            acp::ToolCallConfirmationOutcome::Allow,
-                                            cx,
-                                        );
-                                    }
-                                })),
-                        )
-                        .child(
-                            Button::new(("reject", tool_call_id.0), "Reject")
-                                .icon(IconName::X)
-                                .icon_position(IconPosition::Start)
-                                .icon_size(IconSize::XSmall)
-                                .icon_color(Color::Error)
-                                .label_size(LabelSize::Small)
-                                .on_click(cx.listener({
-                                    let id = tool_call_id;
-                                    move |this, _, _, cx| {
-                                        this.authorize_tool_call(
-                                            id,
-                                            acp::ToolCallConfirmationOutcome::Reject,
-                                            cx,
-                                        );
-                                    }
-                                })),
-                        ),
-                )
+                .child(self.render_confirmation_buttons(
+                    &[AlwaysAllowOption {
+                        id: "always_allow",
+                        label: "Always Allow".into(),
+                        outcome: acp::ToolCallConfirmationOutcome::AlwaysAllow,
+                    }],
+                    tool_call_id,
+                    cx,
+                ))
                 .into_any(),
         }
     }
 
+    fn render_confirmation_buttons(
+        &self,
+        always_allow_options: &[AlwaysAllowOption],
+        tool_call_id: ToolCallId,
+        cx: &Context<Self>,
+    ) -> Div {
+        h_flex()
+            .pt_1p5()
+            .px_1p5()
+            .gap_1()
+            .justify_end()
+            .border_t_1()
+            .border_color(self.tool_card_border_color(cx))
+            .when(self.agent.supports_always_allow(), |this| {
+                this.children(always_allow_options.into_iter().map(|always_allow_option| {
+                    let outcome = always_allow_option.outcome;
+                    Button::new(
+                        (always_allow_option.id, tool_call_id.0),
+                        always_allow_option.label.clone(),
+                    )
+                    .icon(IconName::CheckDouble)
+                    .icon_position(IconPosition::Start)
+                    .icon_size(IconSize::XSmall)
+                    .icon_color(Color::Success)
+                    .on_click(cx.listener({
+                        let id = tool_call_id;
+                        move |this, _, _, cx| {
+                            this.authorize_tool_call(id, outcome, cx);
+                        }
+                    }))
+                }))
+            })
+            .child(
+                Button::new(("allow", tool_call_id.0), "Allow")
+                    .icon(IconName::Check)
+                    .icon_position(IconPosition::Start)
+                    .icon_size(IconSize::XSmall)
+                    .icon_color(Color::Success)
+                    .on_click(cx.listener({
+                        let id = tool_call_id;
+                        move |this, _, _, cx| {
+                            this.authorize_tool_call(
+                                id,
+                                acp::ToolCallConfirmationOutcome::Allow,
+                                cx,
+                            );
+                        }
+                    })),
+            )
+            .child(
+                Button::new(("reject", tool_call_id.0), "Reject")
+                    .icon(IconName::X)
+                    .icon_position(IconPosition::Start)
+                    .icon_size(IconSize::XSmall)
+                    .icon_color(Color::Error)
+                    .on_click(cx.listener({
+                        let id = tool_call_id;
+                        move |this, _, _, cx| {
+                            this.authorize_tool_call(
+                                id,
+                                acp::ToolCallConfirmationOutcome::Reject,
+                                cx,
+                            );
+                        }
+                    })),
+            )
+    }
+
     fn render_diff_editor(&self, multibuffer: &Entity<MultiBuffer>) -> AnyElement {
         v_flex()
             .h_full()
@@ -1466,15 +1286,15 @@ impl AcpThreadView {
             .into_any()
     }
 
-    fn render_gemini_logo(&self) -> AnyElement {
-        Icon::new(IconName::AiGemini)
+    fn render_agent_logo(&self) -> AnyElement {
+        Icon::new(self.agent.logo())
             .color(Color::Muted)
             .size(IconSize::XLarge)
             .into_any_element()
     }
 
-    fn render_error_gemini_logo(&self) -> AnyElement {
-        let logo = Icon::new(IconName::AiGemini)
+    fn render_error_agent_logo(&self) -> AnyElement {
+        let logo = Icon::new(self.agent.logo())
             .color(Color::Muted)
             .size(IconSize::XLarge)
             .into_any_element();
@@ -1493,49 +1313,50 @@ impl AcpThreadView {
             .into_any_element()
     }
 
-    fn render_empty_state(&self, loading: bool, cx: &App) -> AnyElement {
+    fn render_empty_state(&self, cx: &App) -> AnyElement {
+        let loading = matches!(&self.thread_state, ThreadState::Loading { .. });
+
         v_flex()
             .size_full()
             .items_center()
             .justify_center()
-            .child(
-                if loading {
-                    h_flex()
-                        .justify_center()
-                        .child(self.render_gemini_logo())
-                        .with_animation(
-                            "pulsating_icon",
-                            Animation::new(Duration::from_secs(2))
-                                .repeat()
-                                .with_easing(pulsating_between(0.4, 1.0)),
-                            |icon, delta| icon.opacity(delta),
-                        ).into_any()
-                } else {
-                    self.render_gemini_logo().into_any_element()
-                }
-            )
-            .child(
+            .child(if loading {
                 h_flex()
-                    .mt_4()
-                    .mb_1()
                     .justify_center()
-                    .child(Headline::new(if loading {
-                        "Connecting to Gemini…"
-                    } else {
-                        "Welcome to Gemini"
-                    }).size(HeadlineSize::Medium)),
-            )
+                    .child(self.render_agent_logo())
+                    .with_animation(
+                        "pulsating_icon",
+                        Animation::new(Duration::from_secs(2))
+                            .repeat()
+                            .with_easing(pulsating_between(0.4, 1.0)),
+                        |icon, delta| icon.opacity(delta),
+                    )
+                    .into_any()
+            } else {
+                self.render_agent_logo().into_any_element()
+            })
+            .child(h_flex().mt_4().mb_1().justify_center().child(if loading {
+                div()
+                    .child(LoadingLabel::new("").size(LabelSize::Large))
+                    .into_any_element()
+            } else {
+                Headline::new(self.agent.empty_state_headline())
+                    .size(HeadlineSize::Medium)
+                    .into_any_element()
+            }))
             .child(
                 div()
                     .max_w_1_2()
                     .text_sm()
                     .text_center()
-                    .map(|this| if loading {
-                        this.invisible()
-                    } else {
-                        this.text_color(cx.theme().colors().text_muted)
+                    .map(|this| {
+                        if loading {
+                            this.invisible()
+                        } else {
+                            this.text_color(cx.theme().colors().text_muted)
+                        }
                     })
-                    .child("Ask questions, edit files, run commands.\nBe specific for the best results.")
+                    .child(self.agent.empty_state_message()),
             )
             .into_any()
     }
@@ -1544,7 +1365,7 @@ impl AcpThreadView {
         v_flex()
             .items_center()
             .justify_center()
-            .child(self.render_error_gemini_logo())
+            .child(self.render_error_agent_logo())
             .child(
                 h_flex()
                     .mt_4()
@@ -1559,7 +1380,7 @@ impl AcpThreadView {
         let mut container = v_flex()
             .items_center()
             .justify_center()
-            .child(self.render_error_gemini_logo())
+            .child(self.render_error_agent_logo())
             .child(
                 v_flex()
                     .mt_4()
@@ -1575,43 +1396,47 @@ impl AcpThreadView {
                     ),
             );
 
-        if matches!(e, LoadError::Unsupported { .. }) {
-            container =
-                container.child(Button::new("upgrade", "Upgrade Gemini to Latest").on_click(
-                    cx.listener(|this, _, window, cx| {
-                        this.workspace
-                            .update(cx, |workspace, cx| {
-                                let project = workspace.project().read(cx);
-                                let cwd = project.first_project_directory(cx);
-                                let shell = project.terminal_settings(&cwd, cx).shell.clone();
-                                let command =
-                                    "npm install -g @google/gemini-cli@latest".to_string();
-                                let spawn_in_terminal = task::SpawnInTerminal {
-                                    id: task::TaskId("install".to_string()),
-                                    full_label: command.clone(),
-                                    label: command.clone(),
-                                    command: Some(command.clone()),
-                                    args: Vec::new(),
-                                    command_label: command.clone(),
-                                    cwd,
-                                    env: Default::default(),
-                                    use_new_terminal: true,
-                                    allow_concurrent_runs: true,
-                                    reveal: Default::default(),
-                                    reveal_target: Default::default(),
-                                    hide: Default::default(),
-                                    shell,
-                                    show_summary: true,
-                                    show_command: true,
-                                    show_rerun: false,
-                                };
-                                workspace
-                                    .spawn_in_terminal(spawn_in_terminal, window, cx)
-                                    .detach();
-                            })
-                            .ok();
-                    }),
-                ));
+        if let LoadError::Unsupported {
+            upgrade_message,
+            upgrade_command,
+            ..
+        } = &e
+        {
+            let upgrade_message = upgrade_message.clone();
+            let upgrade_command = upgrade_command.clone();
+            container = container.child(Button::new("upgrade", upgrade_message).on_click(
+                cx.listener(move |this, _, window, cx| {
+                    this.workspace
+                        .update(cx, |workspace, cx| {
+                            let project = workspace.project().read(cx);
+                            let cwd = project.first_project_directory(cx);
+                            let shell = project.terminal_settings(&cwd, cx).shell.clone();
+                            let spawn_in_terminal = task::SpawnInTerminal {
+                                id: task::TaskId("install".to_string()),
+                                full_label: upgrade_command.clone(),
+                                label: upgrade_command.clone(),
+                                command: Some(upgrade_command.clone()),
+                                args: Vec::new(),
+                                command_label: upgrade_command.clone(),
+                                cwd,
+                                env: Default::default(),
+                                use_new_terminal: true,
+                                allow_concurrent_runs: true,
+                                reveal: Default::default(),
+                                reveal_target: Default::default(),
+                                hide: Default::default(),
+                                shell,
+                                show_summary: true,
+                                show_command: true,
+                                show_rerun: false,
+                            };
+                            workspace
+                                .spawn_in_terminal(spawn_in_terminal, window, cx)
+                                .detach();
+                        })
+                        .ok();
+                }),
+            ));
         }
 
         container.into_any()
@@ -2267,20 +2092,23 @@ impl Render for AcpThreadView {
             .on_action(cx.listener(Self::next_history_message))
             .on_action(cx.listener(Self::open_agent_diff))
             .child(match &self.thread_state {
-                ThreadState::Unauthenticated { .. } => v_flex()
-                    .p_2()
-                    .flex_1()
-                    .items_center()
-                    .justify_center()
-                    .child(self.render_pending_auth_state())
-                    .child(h_flex().mt_1p5().justify_center().child(
-                        Button::new("sign-in", "Sign in to Gemini").on_click(
-                            cx.listener(|this, _, window, cx| this.authenticate(window, cx)),
-                        ),
-                    )),
-                ThreadState::Loading { .. } => {
-                    v_flex().flex_1().child(self.render_empty_state(true, cx))
+                ThreadState::Unauthenticated { .. } => {
+                    v_flex()
+                        .p_2()
+                        .flex_1()
+                        .items_center()
+                        .justify_center()
+                        .child(self.render_pending_auth_state())
+                        .child(
+                            h_flex().mt_1p5().justify_center().child(
+                                Button::new("sign-in", format!("Sign in to {}", self.agent.name()))
+                                    .on_click(cx.listener(|this, _, window, cx| {
+                                        this.authenticate(window, cx)
+                                    })),
+                            ),
+                        )
                 }
+                ThreadState::Loading { .. } => v_flex().flex_1().child(self.render_empty_state(cx)),
                 ThreadState::LoadError(e) => v_flex()
                     .p_2()
                     .flex_1()
@@ -2321,7 +2149,7 @@ impl Render for AcpThreadView {
                         })
                         .children(self.render_edits_bar(&thread, window, cx))
                     } else {
-                        this.child(self.render_empty_state(false, cx))
+                        this.child(self.render_empty_state(cx))
                     }
                 }),
             })

crates/agent_ui/src/active_thread.rs

@@ -1036,7 +1036,7 @@ impl ActiveThread {
                             .collect::<Vec<_>>()
                             .join("\n");
                         self.last_error = Some(ThreadError::Message {
-                            header: "Error interacting with language model".into(),
+                            header: "Error".into(),
                             message: error_message.into(),
                         });
                     }
@@ -3202,7 +3202,10 @@ impl ActiveThread {
                                 .border_color(self.tool_card_border_color(cx))
                                 .rounded_b_lg()
                                 .child(
-                                    LoadingLabel::new("Waiting for Confirmation").size(LabelSize::Small)
+                                    div()
+                                        .min_w(rems_from_px(145.))
+                                        .child(LoadingLabel::new("Waiting for Confirmation").size(LabelSize::Small)
+                                    )
                                 )
                                 .child(
                                     h_flex()
@@ -3247,7 +3250,6 @@ impl ActiveThread {
                                                 },
                                             ))
                                         })
-                                        .child(ui::Divider::vertical())
                                         .child({
                                             let tool_id = tool_use.id.clone();
                                             Button::new("allow-tool-action", "Allow")

crates/agent_ui/src/agent_diff.rs

@@ -1,5 +1,5 @@
 use crate::{Keep, KeepAll, OpenAgentDiff, Reject, RejectAll};
-use acp::{AcpThread, AcpThreadEvent};
+use acp_thread::{AcpThread, AcpThreadEvent};
 use agent::{Thread, ThreadEvent, ThreadSummary};
 use agent_settings::AgentSettings;
 use anyhow::Result;
@@ -81,7 +81,7 @@ impl AgentDiffThread {
         match self {
             AgentDiffThread::Native(thread) => thread.read(cx).is_generating(),
             AgentDiffThread::AcpThread(thread) => {
-                thread.read(cx).status() == acp::ThreadStatus::Generating
+                thread.read(cx).status() == acp_thread::ThreadStatus::Generating
             }
         }
     }

crates/agent_ui/src/agent_model_selector.rs

@@ -1,8 +1,6 @@
 use crate::{
     ModelUsageContext,
-    language_model_selector::{
-        LanguageModelSelector, ToggleModelSelector, language_model_selector,
-    },
+    language_model_selector::{LanguageModelSelector, language_model_selector},
 };
 use agent_settings::AgentSettings;
 use fs::Fs;
@@ -12,6 +10,7 @@ use picker::popover_menu::PickerPopoverMenu;
 use settings::update_settings_file;
 use std::sync::Arc;
 use ui::{ButtonLike, PopoverMenuHandle, Tooltip, prelude::*};
+use zed_actions::agent::ToggleModelSelector;
 
 pub struct AgentModelSelector {
     selector: Entity<LanguageModelSelector>,
@@ -96,22 +95,18 @@ impl Render for AgentModelSelector {
         let model_name = model
             .as_ref()
             .map(|model| model.model.name().0)
-            .unwrap_or_else(|| SharedString::from("No model selected"));
-        let provider_icon = model
-            .as_ref()
-            .map(|model| model.provider.icon())
-            .unwrap_or_else(|| IconName::Ai);
+            .unwrap_or_else(|| SharedString::from("Select a Model"));
+
+        let provider_icon = model.as_ref().map(|model| model.provider.icon());
 
         let focus_handle = self.focus_handle.clone();
 
         PickerPopoverMenu::new(
             self.selector.clone(),
             ButtonLike::new("active-model")
-                .child(
-                    Icon::new(provider_icon)
-                        .color(Color::Muted)
-                        .size(IconSize::XSmall),
-                )
+                .when_some(provider_icon, |this, icon| {
+                    this.child(Icon::new(icon).color(Color::Muted).size(IconSize::XSmall))
+                })
                 .child(
                     Label::new(model_name)
                         .color(Color::Muted)

crates/agent_ui/src/agent_ui.rs

@@ -25,6 +25,7 @@ mod thread_history;
 mod tool_compatibility;
 mod ui;
 
+use std::rc::Rc;
 use std::sync::Arc;
 
 use agent::{Thread, ThreadId};
@@ -40,7 +41,7 @@ use language_model::{
 };
 use prompt_store::PromptBuilder;
 use schemars::JsonSchema;
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use settings::{Settings as _, SettingsStore};
 
 pub use crate::active_thread::ActiveThread;
@@ -57,8 +58,6 @@ actions!(
     [
         /// Creates a new text-based conversation thread.
         NewTextThread,
-        /// Creates a new external agent conversation thread.
-        NewAcpThread,
         /// Toggles the context picker interface for adding files, symbols, or other context.
         ToggleContextPicker,
         /// Toggles the navigation menu for switching between threads and views.
@@ -133,6 +132,32 @@ pub struct NewThread {
     from_thread_id: Option<ThreadId>,
 }
 
+/// Creates a new external agent conversation thread.
+#[derive(Default, Clone, PartialEq, Deserialize, JsonSchema, Action)]
+#[action(namespace = agent)]
+#[serde(deny_unknown_fields)]
+pub struct NewExternalAgentThread {
+    /// Which agent to use for the conversation.
+    agent: Option<ExternalAgent>,
+}
+
+#[derive(Default, Clone, Copy, PartialEq, Serialize, Deserialize, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+enum ExternalAgent {
+    #[default]
+    Gemini,
+    ClaudeCode,
+}
+
+impl ExternalAgent {
+    pub fn server(&self) -> Rc<dyn agent_servers::AgentServer> {
+        match self {
+            ExternalAgent::Gemini => Rc::new(agent_servers::Gemini),
+            ExternalAgent::ClaudeCode => Rc::new(agent_servers::ClaudeCode),
+        }
+    }
+}
+
 /// Opens the profile management interface for configuring agent tools and settings.
 #[derive(PartialEq, Clone, Default, Debug, Deserialize, JsonSchema, Action)]
 #[action(namespace = agent)]

crates/agent_ui/src/inline_prompt_editor.rs

@@ -2,7 +2,6 @@ use crate::agent_model_selector::AgentModelSelector;
 use crate::buffer_codegen::BufferCodegen;
 use crate::context_picker::{ContextPicker, ContextPickerCompletionProvider};
 use crate::context_strip::{ContextStrip, ContextStripEvent, SuggestContextKind};
-use crate::language_model_selector::ToggleModelSelector;
 use crate::message_editor::{ContextCreasesAddon, extract_message_creases, insert_message_creases};
 use crate::terminal_codegen::TerminalCodegen;
 use crate::{CycleNextInlineAssist, CyclePreviousInlineAssist, ModelUsageContext};
@@ -38,6 +37,7 @@ use ui::{
     CheckboxWithLabel, IconButtonShape, KeyBinding, Popover, PopoverMenuHandle, Tooltip, prelude::*,
 };
 use workspace::Workspace;
+use zed_actions::agent::ToggleModelSelector;
 
 pub struct PromptEditor<T> {
     pub editor: Entity<Editor>,

crates/agent_ui/src/language_model_selector.rs

@@ -3,9 +3,7 @@ use std::{cmp::Reverse, sync::Arc};
 use collections::{HashSet, IndexMap};
 use feature_flags::ZedProFeatureFlag;
 use fuzzy::{StringMatch, StringMatchCandidate, match_strings};
-use gpui::{
-    Action, AnyElement, App, BackgroundExecutor, DismissEvent, Subscription, Task, actions,
-};
+use gpui::{Action, AnyElement, App, BackgroundExecutor, DismissEvent, Subscription, Task};
 use language_model::{
     AuthenticateError, ConfiguredModel, LanguageModel, LanguageModelProviderId,
     LanguageModelRegistry,
@@ -15,15 +13,6 @@ use picker::{Picker, PickerDelegate};
 use proto::Plan;
 use ui::{ListItem, ListItemSpacing, prelude::*};
 
-actions!(
-    agent,
-    [
-        /// Toggles the language model selector dropdown.
-        #[action(deprecated_aliases = ["assistant::ToggleModelSelector", "assistant2::ToggleModelSelector"])]
-        ToggleModelSelector
-    ]
-);
-
 const TRY_ZED_PRO_URL: &str = "https://zed.dev/pro";
 
 type OnModelChanged = Arc<dyn Fn(Arc<dyn LanguageModel>, &mut App) + 'static>;

crates/agent_ui/src/message_editor.rs

@@ -4,7 +4,6 @@ use std::sync::Arc;
 
 use crate::agent_diff::AgentDiffThread;
 use crate::agent_model_selector::AgentModelSelector;
-use crate::language_model_selector::ToggleModelSelector;
 use crate::tool_compatibility::{IncompatibleToolsState, IncompatibleToolsTooltip};
 use crate::ui::{
     MaxModeTooltip,
@@ -29,8 +28,8 @@ use fs::Fs;
 use futures::future::Shared;
 use futures::{FutureExt as _, future};
 use gpui::{
-    Animation, AnimationExt, App, Entity, EventEmitter, Focusable, Subscription, Task, TextStyle,
-    WeakEntity, linear_color_stop, linear_gradient, point, pulsating_between,
+    Animation, AnimationExt, App, Entity, EventEmitter, Focusable, KeyContext, Subscription, Task,
+    TextStyle, WeakEntity, linear_color_stop, linear_gradient, point, pulsating_between,
 };
 use language::{Buffer, Language, Point};
 use language_model::{
@@ -49,6 +48,7 @@ use ui::{
 use util::ResultExt as _;
 use workspace::{CollaboratorId, Workspace};
 use zed_actions::agent::Chat;
+use zed_actions::agent::ToggleModelSelector;
 use zed_llm_client::CompletionIntent;
 
 use crate::context_picker::{ContextPicker, ContextPickerCompletionProvider, crease_for_mention};
@@ -132,6 +132,7 @@ pub(crate) fn create_editor(
             placement: Some(ContextMenuPlacement::Above),
         });
         editor.register_addon(ContextCreasesAddon::new());
+        editor.register_addon(MessageEditorAddon::new());
         editor
     });
 
@@ -609,7 +610,11 @@ impl MessageEditor {
         )
     }
 
-    fn render_follow_toggle(&self, cx: &mut Context<Self>) -> impl IntoElement {
+    fn render_follow_toggle(
+        &self,
+        is_model_selected: bool,
+        cx: &mut Context<Self>,
+    ) -> impl IntoElement {
         let following = self
             .workspace
             .read_with(cx, |workspace, _| {
@@ -618,6 +623,7 @@ impl MessageEditor {
             .unwrap_or(false);
 
         IconButton::new("follow-agent", IconName::Crosshair)
+            .disabled(is_model_selected)
             .icon_size(IconSize::Small)
             .icon_color(Color::Muted)
             .toggle_state(following)
@@ -786,7 +792,7 @@ impl MessageEditor {
                             .justify_between()
                             .child(
                                 h_flex()
-                                    .child(self.render_follow_toggle(cx))
+                                    .child(self.render_follow_toggle(is_model_selected, cx))
                                     .children(self.render_burn_mode_toggle(cx)),
                             )
                             .child(
@@ -1489,6 +1495,31 @@ pub struct ContextCreasesAddon {
     _subscription: Option<Subscription>,
 }
 
+pub struct MessageEditorAddon {}
+
+impl MessageEditorAddon {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl Addon for MessageEditorAddon {
+    fn to_any(&self) -> &dyn std::any::Any {
+        self
+    }
+
+    fn to_any_mut(&mut self) -> Option<&mut dyn std::any::Any> {
+        Some(self)
+    }
+
+    fn extend_key_context(&self, key_context: &mut KeyContext, cx: &App) {
+        let settings = agent_settings::AgentSettings::get_global(cx);
+        if settings.use_modifier_to_send {
+            key_context.add("use_modifier_to_send");
+        }
+    }
+}
+
 impl Addon for ContextCreasesAddon {
     fn to_any(&self) -> &dyn std::any::Any {
         self

crates/agent_ui/src/text_thread_editor.rs

@@ -1,8 +1,6 @@
 use crate::{
     burn_mode_tooltip::BurnModeTooltip,
-    language_model_selector::{
-        LanguageModelSelector, ToggleModelSelector, language_model_selector,
-    },
+    language_model_selector::{LanguageModelSelector, language_model_selector},
 };
 use agent_settings::{AgentSettings, CompletionMode};
 use anyhow::Result;
@@ -38,8 +36,7 @@ use language::{
     language_settings::{SoftWrap, all_language_settings},
 };
 use language_model::{
-    ConfigurationError, LanguageModelExt, LanguageModelImage, LanguageModelProviderTosView,
-    LanguageModelRegistry, Role,
+    ConfigurationError, LanguageModelExt, LanguageModelImage, LanguageModelRegistry, Role,
 };
 use multi_buffer::MultiBufferRow;
 use picker::{Picker, popover_menu::PickerPopoverMenu};
@@ -74,6 +71,7 @@ use workspace::{
     pane,
     searchable::{SearchEvent, SearchableItem},
 };
+use zed_actions::agent::ToggleModelSelector;
 
 use crate::{slash_command::SlashCommandCompletionProvider, slash_command_picker};
 use assistant_context::{
@@ -1895,108 +1893,6 @@ impl TextThreadEditor {
             .update(cx, |context, cx| context.summarize(true, cx));
     }
 
-    fn render_notice(&self, cx: &mut Context<Self>) -> Option<AnyElement> {
-        // This was previously gated behind the `zed-pro` feature flag. Since we
-        // aren't planning to ship that right now, we're just hard-coding this
-        // value to not show the nudge.
-        let nudge = Some(false);
-
-        let model_registry = LanguageModelRegistry::read_global(cx);
-
-        if nudge.map_or(false, |value| value) {
-            Some(
-                h_flex()
-                    .p_3()
-                    .border_b_1()
-                    .border_color(cx.theme().colors().border_variant)
-                    .bg(cx.theme().colors().editor_background)
-                    .justify_between()
-                    .child(
-                        h_flex()
-                            .gap_3()
-                            .child(Icon::new(IconName::ZedAssistant).color(Color::Accent))
-                            .child(Label::new("Zed AI is here! Get started by signing in →")),
-                    )
-                    .child(
-                        Button::new("sign-in", "Sign in")
-                            .size(ButtonSize::Compact)
-                            .style(ButtonStyle::Filled)
-                            .on_click(cx.listener(|this, _event, _window, cx| {
-                                let client = this
-                                    .workspace
-                                    .read_with(cx, |workspace, _| workspace.client().clone())
-                                    .log_err();
-
-                                if let Some(client) = client {
-                                    cx.spawn(async move |context_editor, cx| {
-                                        match client.authenticate_and_connect(true, cx).await {
-                                            util::ConnectionResult::Timeout => {
-                                                log::error!("Authentication timeout")
-                                            }
-                                            util::ConnectionResult::ConnectionReset => {
-                                                log::error!("Connection reset")
-                                            }
-                                            util::ConnectionResult::Result(r) => {
-                                                if r.log_err().is_some() {
-                                                    context_editor
-                                                        .update(cx, |_, cx| cx.notify())
-                                                        .ok();
-                                                }
-                                            }
-                                        }
-                                    })
-                                    .detach()
-                                }
-                            })),
-                    )
-                    .into_any_element(),
-            )
-        } else if let Some(configuration_error) =
-            model_registry.configuration_error(model_registry.default_model(), cx)
-        {
-            Some(
-                h_flex()
-                    .px_3()
-                    .py_2()
-                    .border_b_1()
-                    .border_color(cx.theme().colors().border_variant)
-                    .bg(cx.theme().colors().editor_background)
-                    .justify_between()
-                    .child(
-                        h_flex()
-                            .gap_3()
-                            .child(
-                                Icon::new(IconName::Warning)
-                                    .size(IconSize::Small)
-                                    .color(Color::Warning),
-                            )
-                            .child(Label::new(configuration_error.to_string())),
-                    )
-                    .child(
-                        Button::new("open-configuration", "Configure Providers")
-                            .size(ButtonSize::Compact)
-                            .icon(Some(IconName::SlidersVertical))
-                            .icon_size(IconSize::Small)
-                            .icon_position(IconPosition::Start)
-                            .style(ButtonStyle::Filled)
-                            .on_click({
-                                let focus_handle = self.focus_handle(cx).clone();
-                                move |_event, window, cx| {
-                                    focus_handle.dispatch_action(
-                                        &zed_actions::agent::OpenConfiguration,
-                                        window,
-                                        cx,
-                                    );
-                                }
-                            }),
-                    )
-                    .into_any_element(),
-            )
-        } else {
-            None
-        }
-    }
-
     fn render_send_button(&self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
         let focus_handle = self.focus_handle(cx).clone();
 
@@ -2128,12 +2024,13 @@ impl TextThreadEditor {
             .map(|default| default.model);
         let model_name = match active_model {
             Some(model) => model.name().0,
-            None => SharedString::from("No model selected"),
+            None => SharedString::from("Select Model"),
         };
 
         let active_provider = LanguageModelRegistry::read_global(cx)
             .default_model()
             .map(|default| default.provider);
+
         let provider_icon = match active_provider {
             Some(provider) => provider.icon(),
             None => IconName::Ai,
@@ -2581,20 +2478,7 @@ impl EventEmitter<SearchEvent> for TextThreadEditor {}
 
 impl Render for TextThreadEditor {
     fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let provider = LanguageModelRegistry::read_global(cx)
-            .default_model()
-            .map(|default| default.provider);
-
-        let accept_terms = if self.show_accept_terms {
-            provider.as_ref().and_then(|provider| {
-                provider.render_accept_terms(LanguageModelProviderTosView::PromptEditorPopup, cx)
-            })
-        } else {
-            None
-        };
-
         let language_model_selector = self.language_model_selector_menu_handle.clone();
-        let burn_mode_toggle = self.render_burn_mode_toggle(cx);
 
         v_flex()
             .key_context("ContextEditor")
@@ -2611,28 +2495,12 @@ impl Render for TextThreadEditor {
                 language_model_selector.toggle(window, cx);
             })
             .size_full()
-            .children(self.render_notice(cx))
             .child(
                 div()
                     .flex_grow()
                     .bg(cx.theme().colors().editor_background)
                     .child(self.editor.clone()),
             )
-            .when_some(accept_terms, |this, element| {
-                this.child(
-                    div()
-                        .absolute()
-                        .right_3()
-                        .bottom_12()
-                        .max_w_96()
-                        .py_2()
-                        .px_3()
-                        .elevation_2(cx)
-                        .bg(cx.theme().colors().surface_background)
-                        .occlude()
-                        .child(element),
-                )
-            })
             .children(self.render_last_error(cx))
             .child(
                 h_flex()
@@ -2649,7 +2517,7 @@ impl Render for TextThreadEditor {
                         h_flex()
                             .gap_0p5()
                             .child(self.render_inject_context_menu(cx))
-                            .when_some(burn_mode_toggle, |this, element| this.child(element)),
+                            .children(self.render_burn_mode_toggle(cx)),
                     )
                     .child(
                         h_flex()

crates/agent_ui/src/ui.rs

@@ -1,6 +1,7 @@
 mod agent_notification;
 mod burn_mode_tooltip;
 mod context_pill;
+mod end_trial_upsell;
 mod onboarding_modal;
 pub mod preview;
 mod upsell;
@@ -8,4 +9,5 @@ mod upsell;
 pub use agent_notification::*;
 pub use burn_mode_tooltip::*;
 pub use context_pill::*;
+pub use end_trial_upsell::*;
 pub use onboarding_modal::*;

crates/agent_ui/src/ui/end_trial_upsell.rs

@@ -0,0 +1,112 @@
+use std::sync::Arc;
+
+use ai_onboarding::{AgentPanelOnboardingCard, BulletItem};
+use client::zed_urls;
+use gpui::{AnyElement, App, IntoElement, RenderOnce, Window};
+use ui::{Divider, List, prelude::*};
+
+#[derive(IntoElement, RegisterComponent)]
+pub struct EndTrialUpsell {
+    dismiss_upsell: Arc<dyn Fn(&mut Window, &mut App)>,
+}
+
+impl EndTrialUpsell {
+    pub fn new(dismiss_upsell: Arc<dyn Fn(&mut Window, &mut App)>) -> Self {
+        Self { dismiss_upsell }
+    }
+}
+
+impl RenderOnce for EndTrialUpsell {
+    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
+        let pro_section = v_flex()
+            .gap_1()
+            .child(
+                h_flex()
+                    .gap_2()
+                    .child(
+                        Label::new("Pro")
+                            .size(LabelSize::Small)
+                            .color(Color::Accent)
+                            .buffer_font(cx),
+                    )
+                    .child(Divider::horizontal()),
+            )
+            .child(
+                List::new()
+                    .child(BulletItem::new("500 prompts per month with Claude models"))
+                    .child(BulletItem::new("Unlimited edit predictions")),
+            )
+            .child(
+                Button::new("cta-button", "Upgrade to Zed Pro")
+                    .full_width()
+                    .style(ButtonStyle::Tinted(ui::TintColor::Accent))
+                    .on_click(|_, _, cx| cx.open_url(&zed_urls::upgrade_to_zed_pro_url(cx))),
+            );
+
+        let free_section = v_flex()
+            .mt_1p5()
+            .gap_1()
+            .child(
+                h_flex()
+                    .gap_2()
+                    .child(
+                        Label::new("Free")
+                            .size(LabelSize::Small)
+                            .color(Color::Muted)
+                            .buffer_font(cx),
+                    )
+                    .child(Divider::horizontal()),
+            )
+            .child(
+                List::new()
+                    .child(BulletItem::new(
+                        "50 prompts per month with the Claude models",
+                    ))
+                    .child(BulletItem::new(
+                        "2000 accepted edit predictions using our open-source Zeta model",
+                    )),
+            )
+            .child(
+                Button::new("dismiss-button", "Stay on Free")
+                    .full_width()
+                    .style(ButtonStyle::Outlined)
+                    .on_click({
+                        let callback = self.dismiss_upsell.clone();
+                        move |_, window, cx| callback(window, cx)
+                    }),
+            );
+
+        AgentPanelOnboardingCard::new()
+            .child(Headline::new("Your Zed Pro trial has expired."))
+            .child(
+                Label::new("You've been automatically reset to the Free plan.")
+                    .size(LabelSize::Small)
+                    .color(Color::Muted)
+                    .mb_1(),
+            )
+            .child(pro_section)
+            .child(free_section)
+    }
+}
+
+impl Component for EndTrialUpsell {
+    fn scope() -> ComponentScope {
+        ComponentScope::Agent
+    }
+
+    fn sort_name() -> &'static str {
+        "AgentEndTrialUpsell"
+    }
+
+    fn preview(_window: &mut Window, _cx: &mut App) -> Option<AnyElement> {
+        Some(
+            v_flex()
+                .p_4()
+                .gap_4()
+                .child(EndTrialUpsell {
+                    dismiss_upsell: Arc::new(|_, _| {}),
+                })
+                .into_any_element(),
+        )
+    }
+}

crates/ai_onboarding/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "ai_onboarding"
+version = "0.1.0"
+edition.workspace = true
+publish.workspace = true
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/ai_onboarding.rs"
+
+[features]
+default = []
+
+[dependencies]
+client.workspace = true
+component.workspace = true
+gpui.workspace = true
+language_model.workspace = true
+proto.workspace = true
+serde.workspace = true
+smallvec.workspace = true
+ui.workspace = true
+workspace-hack.workspace = true
+zed_actions.workspace = true

crates/ai_onboarding/LICENSE-GPL

@@ -0,0 +1 @@
+../../LICENSE-GPL

crates/ai_onboarding/src/agent_panel_onboarding_card.rs

@@ -0,0 +1,81 @@
+use gpui::{AnyElement, IntoElement, ParentElement, linear_color_stop, linear_gradient};
+use smallvec::SmallVec;
+use ui::{Vector, VectorName, prelude::*};
+
+#[derive(IntoElement)]
+pub struct AgentPanelOnboardingCard {
+    children: SmallVec<[AnyElement; 2]>,
+}
+
+impl AgentPanelOnboardingCard {
+    pub fn new() -> Self {
+        Self {
+            children: SmallVec::new(),
+        }
+    }
+}
+
+impl ParentElement for AgentPanelOnboardingCard {
+    fn extend(&mut self, elements: impl IntoIterator<Item = AnyElement>) {
+        self.children.extend(elements)
+    }
+}
+
+impl RenderOnce for AgentPanelOnboardingCard {
+    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
+        div()
+            .m_4()
+            .p(px(3.))
+            .elevation_2(cx)
+            .rounded_lg()
+            .bg(cx.theme().colors().background.alpha(0.5))
+            .child(
+                v_flex()
+                    .relative()
+                    .size_full()
+                    .px_4()
+                    .py_3()
+                    .gap_2()
+                    .border_1()
+                    .rounded(px(5.))
+                    .border_color(cx.theme().colors().text.alpha(0.1))
+                    .overflow_hidden()
+                    .bg(cx.theme().colors().panel_background)
+                    .child(
+                        div()
+                            .opacity(0.5)
+                            .absolute()
+                            .top(px(-8.0))
+                            .right_0()
+                            .w(px(400.))
+                            .h(px(92.))
+                            .child(
+                                Vector::new(
+                                    VectorName::AiGrid,
+                                    rems_from_px(400.),
+                                    rems_from_px(92.),
+                                )
+                                .color(Color::Custom(cx.theme().colors().text.alpha(0.32))),
+                            ),
+                    )
+                    .child(
+                        div()
+                            .absolute()
+                            .top_0()
+                            .right_0()
+                            .w(px(660.))
+                            .h(px(401.))
+                            .overflow_hidden()
+                            .bg(linear_gradient(
+                                75.,
+                                linear_color_stop(
+                                    cx.theme().colors().panel_background.alpha(0.01),
+                                    1.0,
+                                ),
+                                linear_color_stop(cx.theme().colors().panel_background, 0.45),
+                            )),
+                    )
+                    .children(self.children),
+            )
+    }
+}

crates/ai_onboarding/src/agent_panel_onboarding_content.rs

@@ -0,0 +1,145 @@
+use std::sync::Arc;
+
+use client::{Client, UserStore};
+use gpui::{Action, ClickEvent, Entity, IntoElement, ParentElement};
+use language_model::{LanguageModelRegistry, ZED_CLOUD_PROVIDER_ID};
+use ui::{Divider, List, prelude::*};
+use zed_actions::agent::{OpenConfiguration, ToggleModelSelector};
+
+use crate::{AgentPanelOnboardingCard, BulletItem, ZedAiOnboarding};
+
+pub struct AgentPanelOnboarding {
+    user_store: Entity<UserStore>,
+    client: Arc<Client>,
+    configured_providers: Vec<(IconName, SharedString)>,
+    continue_with_zed_ai: Arc<dyn Fn(&mut Window, &mut App)>,
+}
+
+impl AgentPanelOnboarding {
+    pub fn new(
+        user_store: Entity<UserStore>,
+        client: Arc<Client>,
+        continue_with_zed_ai: impl Fn(&mut Window, &mut App) + 'static,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        cx.subscribe(
+            &LanguageModelRegistry::global(cx),
+            |this: &mut Self, _registry, event: &language_model::Event, cx| match event {
+                language_model::Event::ProviderStateChanged
+                | language_model::Event::AddedProvider(_)
+                | language_model::Event::RemovedProvider(_) => {
+                    this.configured_providers = Self::compute_available_providers(cx)
+                }
+                _ => {}
+            },
+        )
+        .detach();
+
+        Self {
+            user_store,
+            client,
+            configured_providers: Self::compute_available_providers(cx),
+            continue_with_zed_ai: Arc::new(continue_with_zed_ai),
+        }
+    }
+
+    fn compute_available_providers(cx: &App) -> Vec<(IconName, SharedString)> {
+        LanguageModelRegistry::read_global(cx)
+            .providers()
+            .iter()
+            .filter(|provider| {
+                provider.is_authenticated(cx) && provider.id() != ZED_CLOUD_PROVIDER_ID
+            })
+            .map(|provider| (provider.icon(), provider.name().0.clone()))
+            .collect()
+    }
+
+    fn configure_providers(&mut self, _: &ClickEvent, window: &mut Window, cx: &mut Context<Self>) {
+        window.dispatch_action(OpenConfiguration.boxed_clone(), cx);
+        cx.notify();
+    }
+
+    fn render_api_keys_section(&mut self, cx: &mut Context<Self>) -> impl IntoElement {
+        let has_existing_providers = self.configured_providers.len() > 0;
+        let configure_provider_label = if has_existing_providers {
+            "Configure Other Provider"
+        } else {
+            "Configure Providers"
+        };
+
+        let content = if has_existing_providers {
+            List::new()
+                    .child(BulletItem::new(
+                        "Or start now using API keys from your environment for the following providers:"
+                    ))
+                    .child(
+                        h_flex()
+                            .px_5()
+                            .gap_2()
+                            .flex_wrap()
+                            .children(self.configured_providers.iter().cloned().map(|(icon, name)|
+                                h_flex()
+                                    .gap_1p5()
+                                    .child(Icon::new(icon).size(IconSize::Small).color(Color::Muted))
+                                    .child(Label::new(name))
+                            ))
+                    )
+                    .child(BulletItem::new(
+                        "No need for any of the plans or even to sign in",
+                    ))
+        } else {
+            List::new()
+                .child(BulletItem::new(
+                    "You can also use AI in Zed by bringing your own API keys",
+                ))
+                .child(BulletItem::new(
+                    "No need for any of the plans or even to sign in",
+                ))
+        };
+
+        v_flex()
+            .mt_2()
+            .gap_1()
+            .child(
+                h_flex()
+                    .gap_2()
+                    .child(
+                        Label::new("API Keys")
+                            .size(LabelSize::Small)
+                            .color(Color::Muted)
+                            .buffer_font(cx),
+                    )
+                    .child(Divider::horizontal()),
+            )
+            .child(content)
+            .when(has_existing_providers, |this| {
+                this.child(
+                    Button::new("pick-model", "Choose Model")
+                        .full_width()
+                        .style(ButtonStyle::Outlined)
+                        .on_click(|_event, window, cx| {
+                            window.dispatch_action(ToggleModelSelector.boxed_clone(), cx)
+                        }),
+                )
+            })
+            .child(
+                Button::new("configure-providers", configure_provider_label)
+                    .full_width()
+                    .style(ButtonStyle::Outlined)
+                    .on_click(cx.listener(Self::configure_providers)),
+            )
+    }
+}
+
+impl Render for AgentPanelOnboarding {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        AgentPanelOnboardingCard::new()
+            .child(ZedAiOnboarding::new(
+                self.client.clone(),
+                &self.user_store,
+                self.continue_with_zed_ai.clone(),
+                cx,
+            ))
+            .child(self.render_api_keys_section(cx))
+    }
+}

crates/ai_onboarding/src/ai_onboarding.rs

@@ -0,0 +1,397 @@
+mod agent_panel_onboarding_card;
+mod agent_panel_onboarding_content;
+mod edit_prediction_onboarding_content;
+mod young_account_banner;
+
+pub use agent_panel_onboarding_card::AgentPanelOnboardingCard;
+pub use agent_panel_onboarding_content::AgentPanelOnboarding;
+pub use edit_prediction_onboarding_content::EditPredictionOnboarding;
+pub use young_account_banner::YoungAccountBanner;
+
+use std::sync::Arc;
+
+use client::{Client, UserStore, zed_urls};
+use gpui::{AnyElement, Entity, IntoElement, ParentElement, SharedString};
+use ui::{Divider, List, ListItem, RegisterComponent, TintColor, prelude::*};
+
+pub struct BulletItem {
+    label: SharedString,
+}
+
+impl BulletItem {
+    pub fn new(label: impl Into<SharedString>) -> Self {
+        Self {
+            label: label.into(),
+        }
+    }
+}
+
+impl IntoElement for BulletItem {
+    type Element = AnyElement;
+
+    fn into_element(self) -> Self::Element {
+        ListItem::new("list-item")
+            .selectable(false)
+            .start_slot(
+                Icon::new(IconName::Dash)
+                    .size(IconSize::XSmall)
+                    .color(Color::Hidden),
+            )
+            .child(div().w_full().child(Label::new(self.label)))
+            .into_any_element()
+    }
+}
+
+pub enum SignInStatus {
+    SignedIn,
+    SigningIn,
+    SignedOut,
+}
+
+impl From<client::Status> for SignInStatus {
+    fn from(status: client::Status) -> Self {
+        if status.is_signing_in() {
+            Self::SigningIn
+        } else if status.is_signed_out() {
+            Self::SignedOut
+        } else {
+            Self::SignedIn
+        }
+    }
+}
+
+#[derive(RegisterComponent, IntoElement)]
+pub struct ZedAiOnboarding {
+    pub sign_in_status: SignInStatus,
+    pub has_accepted_terms_of_service: bool,
+    pub plan: Option<proto::Plan>,
+    pub account_too_young: bool,
+    pub continue_with_zed_ai: Arc<dyn Fn(&mut Window, &mut App)>,
+    pub sign_in: Arc<dyn Fn(&mut Window, &mut App)>,
+    pub accept_terms_of_service: Arc<dyn Fn(&mut Window, &mut App)>,
+}
+
+impl ZedAiOnboarding {
+    pub fn new(
+        client: Arc<Client>,
+        user_store: &Entity<UserStore>,
+        continue_with_zed_ai: Arc<dyn Fn(&mut Window, &mut App)>,
+        cx: &mut App,
+    ) -> Self {
+        let store = user_store.read(cx);
+        let status = *client.status().borrow();
+        Self {
+            sign_in_status: status.into(),
+            has_accepted_terms_of_service: store.current_user_has_accepted_terms().unwrap_or(false),
+            plan: store.current_plan(),
+            account_too_young: store.account_too_young(),
+            continue_with_zed_ai,
+            accept_terms_of_service: Arc::new({
+                let store = user_store.clone();
+                move |_window, cx| {
+                    let task = store.update(cx, |store, cx| store.accept_terms_of_service(cx));
+                    task.detach_and_log_err(cx);
+                }
+            }),
+            sign_in: Arc::new(move |_window, cx| {
+                cx.spawn({
+                    let client = client.clone();
+                    async move |cx| {
+                        client.authenticate_and_connect(true, cx).await;
+                    }
+                })
+                .detach();
+            }),
+        }
+    }
+
+    fn render_free_plan_section(&self, cx: &mut App) -> impl IntoElement {
+        v_flex()
+            .mt_2()
+            .gap_1()
+            .when(self.account_too_young, |this| this.opacity(0.4))
+            .child(
+                h_flex()
+                    .gap_2()
+                    .child(
+                        Label::new("Free")
+                            .size(LabelSize::Small)
+                            .color(Color::Muted)
+                            .buffer_font(cx),
+                    )
+                    .child(Divider::horizontal()),
+            )
+            .child(
+                List::new()
+                    .child(BulletItem::new(
+                        "50 prompts per month with the Claude models",
+                    ))
+                    .child(BulletItem::new(
+                        "2000 accepted edit predictions using our open-source Zeta model",
+                    )),
+            )
+            .child(
+                Button::new("continue", "Continue Free")
+                    .disabled(self.account_too_young)
+                    .full_width()
+                    .style(ButtonStyle::Outlined)
+                    .on_click({
+                        let callback = self.continue_with_zed_ai.clone();
+                        move |_, window, cx| callback(window, cx)
+                    }),
+            )
+    }
+
+    fn render_pro_plan_section(&self, cx: &mut App) -> impl IntoElement {
+        let (button_label, button_url) = if self.account_too_young {
+            ("Start with Pro", zed_urls::upgrade_to_zed_pro_url(cx))
+        } else {
+            ("Start Pro Trial", zed_urls::account_url(cx))
+        };
+
+        v_flex()
+            .mt_2()
+            .gap_1()
+            .child(
+                h_flex()
+                    .gap_2()
+                    .child(
+                        Label::new("Pro")
+                            .size(LabelSize::Small)
+                            .color(Color::Accent)
+                            .buffer_font(cx),
+                    )
+                    .child(Divider::horizontal()),
+            )
+            .child(
+                List::new()
+                    .child(BulletItem::new("500 prompts per month with Claude models"))
+                    .child(BulletItem::new("Unlimited edit predictions"))
+                    .when(!self.account_too_young, |this| {
+                        this.child(BulletItem::new(
+                            "Try it out for 14 days with no charge, no credit card required",
+                        ))
+                    }),
+            )
+            .child(
+                Button::new("pro", button_label)
+                    .full_width()
+                    .style(ButtonStyle::Tinted(ui::TintColor::Accent))
+                    .on_click(move |_, _window, cx| cx.open_url(&button_url)),
+            )
+    }
+
+    fn render_accept_terms_of_service(&self) -> Div {
+        v_flex()
+            .w_full()
+            .gap_1()
+            .child(Headline::new("Before starting…"))
+            .child(Label::new(
+                "Make sure you have read and accepted Zed AI's terms of service.",
+            ))
+            .child(
+                Button::new("terms_of_service", "View and Read the Terms of Service")
+                    .full_width()
+                    .style(ButtonStyle::Outlined)
+                    .icon(IconName::ArrowUpRight)
+                    .icon_color(Color::Muted)
+                    .icon_size(IconSize::XSmall)
+                    .on_click(move |_, _window, cx| {
+                        cx.open_url("https://zed.dev/terms-of-service")
+                    }),
+            )
+            .child(
+                Button::new("accept_terms", "I've read it and accept it")
+                    .full_width()
+                    .style(ButtonStyle::Tinted(TintColor::Accent))
+                    .on_click({
+                        let callback = self.accept_terms_of_service.clone();
+                        move |_, window, cx| (callback)(window, cx)
+                    }),
+            )
+    }
+
+    fn render_sign_in_disclaimer(&self, _cx: &mut App) -> Div {
+        const SIGN_IN_DISCLAIMER: &str =
+            "To start using AI in Zed with our hosted models, sign in and subscribe to a plan.";
+        let signing_in = matches!(self.sign_in_status, SignInStatus::SigningIn);
+
+        v_flex()
+            .gap_2()
+            .child(Headline::new("Welcome to Zed AI"))
+            .child(div().w_full().child(Label::new(SIGN_IN_DISCLAIMER)))
+            .child(
+                Button::new("sign_in", "Sign In with GitHub")
+                    .icon(IconName::Github)
+                    .icon_position(IconPosition::Start)
+                    .icon_size(IconSize::Small)
+                    .icon_color(Color::Muted)
+                    .disabled(signing_in)
+                    .full_width()
+                    .style(ButtonStyle::Tinted(ui::TintColor::Accent))
+                    .on_click({
+                        let callback = self.sign_in.clone();
+                        move |_, window, cx| callback(window, cx)
+                    }),
+            )
+    }
+
+    fn render_free_plan_onboarding(&self, cx: &mut App) -> Div {
+        const PLANS_DESCRIPTION: &str = "Choose how you want to start.";
+        let young_account_banner = YoungAccountBanner;
+
+        v_flex()
+            .child(Headline::new("Welcome to Zed AI"))
+            .child(
+                Label::new(PLANS_DESCRIPTION)
+                    .size(LabelSize::Small)
+                    .color(Color::Muted)
+                    .mt_1()
+                    .mb_3(),
+            )
+            .when(self.account_too_young, |this| {
+                this.child(young_account_banner)
+            })
+            .child(self.render_free_plan_section(cx))
+            .child(self.render_pro_plan_section(cx))
+    }
+
+    fn render_trial_onboarding(&self, _cx: &mut App) -> Div {
+        v_flex()
+            .child(Headline::new("Welcome to the trial of Zed Pro"))
+            .child(
+                Label::new("Here's what you get for the next 14 days:")
+                    .size(LabelSize::Small)
+                    .color(Color::Muted)
+                    .mt_1(),
+            )
+            .child(
+                List::new()
+                    .child(BulletItem::new("150 prompts with Claude models"))
+                    .child(BulletItem::new(
+                        "Unlimited edit predictions with Zeta, our open-source model",
+                    )),
+            )
+            .child(
+                Button::new("trial", "Start Trial")
+                    .full_width()
+                    .style(ButtonStyle::Outlined)
+                    .on_click({
+                        let callback = self.continue_with_zed_ai.clone();
+                        move |_, window, cx| callback(window, cx)
+                    }),
+            )
+    }
+
+    fn render_pro_plan_onboarding(&self, _cx: &mut App) -> Div {
+        v_flex()
+            .child(Headline::new("Welcome to Zed Pro"))
+            .child(
+                Label::new("Here's what you get:")
+                    .size(LabelSize::Small)
+                    .color(Color::Muted)
+                    .mt_1(),
+            )
+            .child(
+                List::new()
+                    .child(BulletItem::new("500 prompts with Claude models"))
+                    .child(BulletItem::new("Unlimited edit predictions")),
+            )
+            .child(
+                Button::new("pro", "Continue with Zed Pro")
+                    .full_width()
+                    .style(ButtonStyle::Outlined)
+                    .on_click({
+                        let callback = self.continue_with_zed_ai.clone();
+                        move |_, window, cx| callback(window, cx)
+                    }),
+            )
+    }
+}
+
+impl RenderOnce for ZedAiOnboarding {
+    fn render(self, _window: &mut ui::Window, cx: &mut App) -> impl IntoElement {
+        if matches!(self.sign_in_status, SignInStatus::SignedIn) {
+            if self.has_accepted_terms_of_service {
+                match self.plan {
+                    None | Some(proto::Plan::Free) => self.render_free_plan_onboarding(cx),
+                    Some(proto::Plan::ZedProTrial) => self.render_trial_onboarding(cx),
+                    Some(proto::Plan::ZedPro) => self.render_pro_plan_onboarding(cx),
+                }
+            } else {
+                self.render_accept_terms_of_service()
+            }
+        } else {
+            self.render_sign_in_disclaimer(cx)
+        }
+    }
+}
+
+impl Component for ZedAiOnboarding {
+    fn scope() -> ComponentScope {
+        ComponentScope::Agent
+    }
+
+    fn preview(_window: &mut Window, _cx: &mut App) -> Option<AnyElement> {
+        fn onboarding(
+            sign_in_status: SignInStatus,
+            has_accepted_terms_of_service: bool,
+            plan: Option<proto::Plan>,
+            account_too_young: bool,
+        ) -> AnyElement {
+            ZedAiOnboarding {
+                sign_in_status,
+                has_accepted_terms_of_service,
+                plan,
+                account_too_young,
+                continue_with_zed_ai: Arc::new(|_, _| {}),
+                sign_in: Arc::new(|_, _| {}),
+                accept_terms_of_service: Arc::new(|_, _| {}),
+            }
+            .into_any_element()
+        }
+
+        Some(
+            v_flex()
+                .p_4()
+                .gap_4()
+                .children(vec![
+                    single_example(
+                        "Not Signed-in",
+                        onboarding(SignInStatus::SignedOut, false, None, false),
+                    ),
+                    single_example(
+                        "Not Accepted ToS",
+                        onboarding(SignInStatus::SignedIn, false, None, false),
+                    ),
+                    single_example(
+                        "Account too young",
+                        onboarding(SignInStatus::SignedIn, false, None, true),
+                    ),
+                    single_example(
+                        "Free Plan",
+                        onboarding(SignInStatus::SignedIn, true, Some(proto::Plan::Free), false),
+                    ),
+                    single_example(
+                        "Pro Trial",
+                        onboarding(
+                            SignInStatus::SignedIn,
+                            true,
+                            Some(proto::Plan::ZedProTrial),
+                            false,
+                        ),
+                    ),
+                    single_example(
+                        "Pro Plan",
+                        onboarding(
+                            SignInStatus::SignedIn,
+                            true,
+                            Some(proto::Plan::ZedPro),
+                            false,
+                        ),
+                    ),
+                ])
+                .into_any_element(),
+        )
+    }
+}

crates/ai_onboarding/src/edit_prediction_onboarding_content.rs

@@ -0,0 +1,73 @@
+use std::sync::Arc;
+
+use client::{Client, UserStore};
+use gpui::{Entity, IntoElement, ParentElement};
+use ui::prelude::*;
+
+use crate::ZedAiOnboarding;
+
+pub struct EditPredictionOnboarding {
+    user_store: Entity<UserStore>,
+    client: Arc<Client>,
+    copilot_is_configured: bool,
+    continue_with_zed_ai: Arc<dyn Fn(&mut Window, &mut App)>,
+    continue_with_copilot: Arc<dyn Fn(&mut Window, &mut App)>,
+}
+
+impl EditPredictionOnboarding {
+    pub fn new(
+        user_store: Entity<UserStore>,
+        client: Arc<Client>,
+        copilot_is_configured: bool,
+        continue_with_zed_ai: Arc<dyn Fn(&mut Window, &mut App)>,
+        continue_with_copilot: Arc<dyn Fn(&mut Window, &mut App)>,
+        _cx: &mut Context<Self>,
+    ) -> Self {
+        Self {
+            user_store,
+            copilot_is_configured,
+            client,
+            continue_with_zed_ai,
+            continue_with_copilot,
+        }
+    }
+}
+
+impl Render for EditPredictionOnboarding {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let github_copilot = v_flex()
+            .gap_1()
+            .child(Label::new(if self.copilot_is_configured {
+                "Alternatively, you can continue to use GitHub Copilot as that's already set up."
+            } else {
+                "Alternatively, you can use GitHub Copilot as your edit prediction provider."
+            }))
+            .child(
+                Button::new(
+                    "configure-copilot",
+                    if self.copilot_is_configured {
+                        "Use Copilot"
+                    } else {
+                        "Configure Copilot"
+                    },
+                )
+                .full_width()
+                .style(ButtonStyle::Outlined)
+                .on_click({
+                    let callback = self.continue_with_copilot.clone();
+                    move |_, window, cx| callback(window, cx)
+                }),
+            );
+
+        v_flex()
+            .gap_2()
+            .child(ZedAiOnboarding::new(
+                self.client.clone(),
+                &self.user_store,
+                self.continue_with_zed_ai.clone(),
+                cx,
+            ))
+            .child(ui::Divider::horizontal())
+            .child(github_copilot)
+    }
+}

crates/ai_onboarding/src/young_account_banner.rs

@@ -0,0 +1,21 @@
+use gpui::{IntoElement, ParentElement};
+use ui::{Banner, prelude::*};
+
+#[derive(IntoElement)]
+pub struct YoungAccountBanner;
+
+impl RenderOnce for YoungAccountBanner {
+    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
+        const YOUNG_ACCOUNT_DISCLAIMER: &str = "Given your GitHub account was created less than 30 days ago, we cannot put you in the Free plan or offer you a free trial of the Pro plan. We hope you'll understand, as this is unfortunately required to prevent abuse of our service. To continue, upgrade to Pro or use your own API keys for other providers.";
+
+        let label = div()
+            .w_full()
+            .text_sm()
+            .text_color(cx.theme().colors().text_muted)
+            .child(YOUNG_ACCOUNT_DISCLAIMER);
+
+        div()
+            .my_1()
+            .child(Banner::new().severity(ui::Severity::Warning).child(label))
+    }
+}

crates/assistant_tool/src/action_log.rs

@@ -331,16 +331,17 @@ impl ActionLog {
                 .get_mut(buffer)
                 .context("buffer not tracked")?;
 
-            if let ChangeAuthor::User = author {
-                tracked_buffer.has_unnotified_user_edits = true;
-            }
-
             let rebase = cx.background_spawn({
                 let mut base_text = tracked_buffer.diff_base.clone();
                 let old_snapshot = tracked_buffer.snapshot.clone();
                 let new_snapshot = buffer_snapshot.clone();
                 let unreviewed_edits = tracked_buffer.unreviewed_edits.clone();
                 let edits = diff_snapshots(&old_snapshot, &new_snapshot);
+                if let ChangeAuthor::User = author
+                    && !edits.is_empty()
+                {
+                    tracked_buffer.has_unnotified_user_edits = true;
+                }
                 async move {
                     if let ChangeAuthor::User = author {
                         apply_non_conflicting_edits(

crates/assistant_tools/src/edit_agent/evals.rs

@@ -12,6 +12,7 @@ use collections::HashMap;
 use fs::FakeFs;
 use futures::{FutureExt, future::LocalBoxFuture};
 use gpui::{AppContext, TestAppContext, Timer};
+use http_client::StatusCode;
 use indoc::{formatdoc, indoc};
 use language_model::{
     LanguageModelRegistry, LanguageModelRequestTool, LanguageModelToolResult,
@@ -1675,6 +1676,30 @@ async fn retry_on_rate_limit<R>(mut request: impl AsyncFnMut() -> Result<R>) ->
                         Timer::after(retry_after + jitter).await;
                         continue;
                     }
+                    LanguageModelCompletionError::UpstreamProviderError {
+                        status,
+                        retry_after,
+                        ..
+                    } => {
+                        // Only retry for specific status codes
+                        let should_retry = matches!(
+                            *status,
+                            StatusCode::TOO_MANY_REQUESTS | StatusCode::SERVICE_UNAVAILABLE
+                        ) || status.as_u16() == 529;
+
+                        if !should_retry {
+                            return Err(err.into());
+                        }
+
+                        // Use server-provided retry_after if available, otherwise use default
+                        let retry_after = retry_after.unwrap_or(Duration::from_secs(5));
+                        let jitter = retry_after.mul_f64(rand::thread_rng().gen_range(0.0..1.0));
+                        eprintln!(
+                            "Attempt #{attempt}: {err}. Retry after {retry_after:?} + jitter of {jitter:?}"
+                        );
+                        Timer::after(retry_after + jitter).await;
+                        continue;
+                    }
                     _ => return Err(err.into()),
                 },
                 Err(err) => return Err(err),

crates/client/src/client.rs

@@ -301,6 +301,13 @@ impl Status {
         matches!(self, Self::Connected { .. })
     }
 
+    pub fn is_signing_in(&self) -> bool {
+        matches!(
+            self,
+            Self::Authenticating | Self::Reauthenticating | Self::Connecting | Self::Reconnecting
+        )
+    }
+
     pub fn is_signed_out(&self) -> bool {
         matches!(self, Self::SignedOut | Self::UpgradeRequired)
     }

crates/client/src/user.rs

@@ -764,6 +764,16 @@ impl UserStore {
     }
 
     pub fn current_plan(&self) -> Option<proto::Plan> {
+        #[cfg(debug_assertions)]
+        if let Ok(plan) = std::env::var("ZED_SIMULATE_ZED_PRO_PLAN").as_ref() {
+            return match plan.as_str() {
+                "free" => Some(proto::Plan::Free),
+                "trial" => Some(proto::Plan::ZedProTrial),
+                "pro" => Some(proto::Plan::ZedPro),
+                _ => None,
+            };
+        }
+
         self.current_plan
     }
 

crates/client/src/zed_urls.rs

@@ -17,3 +17,8 @@ fn server_url(cx: &App) -> &str {
 pub fn account_url(cx: &App) -> String {
     format!("{server_url}/account", server_url = server_url(cx))
 }
+
+/// Returns the URL to the upgrade page on zed.dev.
+pub fn upgrade_to_zed_pro_url(cx: &App) -> String {
+    format!("{server_url}/account/upgrade", server_url = server_url(cx))
+}

crates/collab/Cargo.toml

@@ -35,7 +35,7 @@ dashmap.workspace = true
 derive_more.workspace = true
 envy = "0.4.2"
 futures.workspace = true
-gpui = { workspace = true, features = ["screen-capture"] }
+gpui.workspace = true
 hex.workspace = true
 http_client.workspace = true
 jsonwebtoken.workspace = true

crates/collab/src/api.rs

@@ -100,6 +100,7 @@ pub fn routes(rpc_server: Arc<rpc::Server>) -> Router<(), Body> {
         .route("/user", get(update_or_create_authenticated_user))
         .route("/users/look_up", get(look_up_user))
         .route("/users/:id/access_tokens", post(create_access_token))
+        .route("/users/:id/refresh_llm_tokens", post(refresh_llm_tokens))
         .route("/rpc_server_snapshot", get(get_rpc_server_snapshot))
         .merge(billing::router())
         .merge(contributors::router())
@@ -334,3 +335,15 @@ async fn create_access_token(
         encrypted_access_token,
     }))
 }
+
+#[derive(Serialize)]
+struct RefreshLlmTokensResponse {}
+
+async fn refresh_llm_tokens(
+    Path(user_id): Path<UserId>,
+    Extension(rpc_server): Extension<Arc<rpc::Server>>,
+) -> Result<Json<RefreshLlmTokensResponse>> {
+    rpc_server.refresh_llm_tokens_for_user(user_id).await;
+
+    Ok(Json(RefreshLlmTokensResponse {}))
+}

crates/collab/src/api/billing.rs

@@ -1,10 +1,6 @@
 use anyhow::{Context as _, bail};
 use axum::routing::put;
-use axum::{
-    Extension, Json, Router,
-    extract::{self, Query},
-    routing::{get, post},
-};
+use axum::{Extension, Json, Router, extract, routing::post};
 use chrono::{DateTime, SecondsFormat, Utc};
 use collections::{HashMap, HashSet};
 use reqwest::StatusCode;
@@ -28,7 +24,6 @@ use crate::api::events::SnowflakeRow;
 use crate::db::billing_subscription::{
     StripeCancellationReason, StripeSubscriptionStatus, SubscriptionKind,
 };
-use crate::llm::AGENT_EXTENDED_TRIAL_FEATURE_FLAG;
 use crate::llm::db::subscription_usage_meter::{self, CompletionMode};
 use crate::rpc::{ResultExt as _, Server};
 use crate::stripe_client::{
@@ -58,7 +53,6 @@ pub fn router() -> Router {
             "/billing/subscriptions/sync",
             post(sync_billing_subscription),
         )
-        .route("/billing/usage", get(get_current_usage))
 }
 
 #[derive(Debug, Serialize)]
@@ -1027,157 +1021,6 @@ async fn handle_customer_subscription_event(
     Ok(())
 }
 
-#[derive(Debug, Deserialize)]
-struct GetCurrentUsageParams {
-    github_user_id: i32,
-}
-
-#[derive(Debug, Serialize)]
-struct UsageCounts {
-    pub used: i32,
-    pub limit: Option<i32>,
-    pub remaining: Option<i32>,
-}
-
-#[derive(Debug, Serialize)]
-struct ModelRequestUsage {
-    pub model: String,
-    pub mode: CompletionMode,
-    pub requests: i32,
-}
-
-#[derive(Debug, Serialize)]
-struct CurrentUsage {
-    pub model_requests: UsageCounts,
-    pub model_request_usage: Vec<ModelRequestUsage>,
-    pub edit_predictions: UsageCounts,
-}
-
-#[derive(Debug, Default, Serialize)]
-struct GetCurrentUsageResponse {
-    pub plan: String,
-    pub current_usage: Option<CurrentUsage>,
-}
-
-async fn get_current_usage(
-    Extension(app): Extension<Arc<AppState>>,
-    Query(params): Query<GetCurrentUsageParams>,
-) -> Result<Json<GetCurrentUsageResponse>> {
-    let user = app
-        .db
-        .get_user_by_github_user_id(params.github_user_id)
-        .await?
-        .context("user not found")?;
-
-    let feature_flags = app.db.get_user_flags(user.id).await?;
-    let has_extended_trial = feature_flags
-        .iter()
-        .any(|flag| flag == AGENT_EXTENDED_TRIAL_FEATURE_FLAG);
-
-    let Some(llm_db) = app.llm_db.clone() else {
-        return Err(Error::http(
-            StatusCode::NOT_IMPLEMENTED,
-            "LLM database not available".into(),
-        ));
-    };
-
-    let Some(subscription) = app.db.get_active_billing_subscription(user.id).await? else {
-        return Ok(Json(GetCurrentUsageResponse::default()));
-    };
-
-    let subscription_period = maybe!({
-        let period_start_at = subscription.current_period_start_at()?;
-        let period_end_at = subscription.current_period_end_at()?;
-
-        Some((period_start_at, period_end_at))
-    });
-
-    let Some((period_start_at, period_end_at)) = subscription_period else {
-        return Ok(Json(GetCurrentUsageResponse::default()));
-    };
-
-    let usage = llm_db
-        .get_subscription_usage_for_period(user.id, period_start_at, period_end_at)
-        .await?;
-
-    let plan = subscription
-        .kind
-        .map(Into::into)
-        .unwrap_or(zed_llm_client::Plan::ZedFree);
-
-    let model_requests_limit = match plan.model_requests_limit() {
-        zed_llm_client::UsageLimit::Limited(limit) => {
-            let limit = if plan == zed_llm_client::Plan::ZedProTrial && has_extended_trial {
-                1_000
-            } else {
-                limit
-            };
-
-            Some(limit)
-        }
-        zed_llm_client::UsageLimit::Unlimited => None,
-    };
-
-    let edit_predictions_limit = match plan.edit_predictions_limit() {
-        zed_llm_client::UsageLimit::Limited(limit) => Some(limit),
-        zed_llm_client::UsageLimit::Unlimited => None,
-    };
-
-    let Some(usage) = usage else {
-        return Ok(Json(GetCurrentUsageResponse {
-            plan: plan.as_str().to_string(),
-            current_usage: Some(CurrentUsage {
-                model_requests: UsageCounts {
-                    used: 0,
-                    limit: model_requests_limit,
-                    remaining: model_requests_limit,
-                },
-                model_request_usage: Vec::new(),
-                edit_predictions: UsageCounts {
-                    used: 0,
-                    limit: edit_predictions_limit,
-                    remaining: edit_predictions_limit,
-                },
-            }),
-        }));
-    };
-
-    let subscription_usage_meters = llm_db
-        .get_current_subscription_usage_meters_for_user(user.id, Utc::now())
-        .await?;
-
-    let model_request_usage = subscription_usage_meters
-        .into_iter()
-        .filter_map(|(usage_meter, _usage)| {
-            let model = llm_db.model_by_id(usage_meter.model_id).ok()?;
-
-            Some(ModelRequestUsage {
-                model: model.name.clone(),
-                mode: usage_meter.mode,
-                requests: usage_meter.requests,
-            })
-        })
-        .collect::<Vec<_>>();
-
-    Ok(Json(GetCurrentUsageResponse {
-        plan: plan.as_str().to_string(),
-        current_usage: Some(CurrentUsage {
-            model_requests: UsageCounts {
-                used: usage.model_requests,
-                limit: model_requests_limit,
-                remaining: model_requests_limit.map(|limit| (limit - usage.model_requests).max(0)),
-            },
-            model_request_usage,
-            edit_predictions: UsageCounts {
-                used: usage.edit_predictions,
-                limit: edit_predictions_limit,
-                remaining: edit_predictions_limit
-                    .map(|limit| (limit - usage.edit_predictions).max(0)),
-            },
-        }),
-    }))
-}
-
 impl From<SubscriptionStatus> for StripeSubscriptionStatus {
     fn from(value: SubscriptionStatus) -> Self {
         match value {

crates/collab/src/api/events.rs

@@ -389,53 +389,58 @@ pub async fn post_panic(
         }
     }
 
-    let backtrace = if panic.backtrace.len() > 25 {
-        let total = panic.backtrace.len();
-        format!(
-            "{}\n   and {} more",
-            panic
-                .backtrace
-                .iter()
-                .take(20)
-                .cloned()
-                .collect::<Vec<_>>()
-                .join("\n"),
-            total - 20
-        )
-    } else {
-        panic.backtrace.join("\n")
-    };
-
     if !report_to_slack(&panic) {
         return Ok(());
     }
 
-    let backtrace_with_summary = panic.payload + "\n" + &backtrace;
-
     if let Some(slack_panics_webhook) = app.config.slack_panics_webhook.clone() {
+        let backtrace = if panic.backtrace.len() > 25 {
+            let total = panic.backtrace.len();
+            format!(
+                "{}\n   and {} more",
+                panic
+                    .backtrace
+                    .iter()
+                    .take(20)
+                    .cloned()
+                    .collect::<Vec<_>>()
+                    .join("\n"),
+                total - 20
+            )
+        } else {
+            panic.backtrace.join("\n")
+        };
+        let backtrace_with_summary = panic.payload + "\n" + &backtrace;
+
+        let version = if panic.release_channel == "nightly"
+            && !panic.app_version.contains("remote-server")
+            && let Some(sha) = panic.app_commit_sha
+        {
+            format!("Zed Nightly {}", sha.chars().take(7).collect::<String>())
+        } else {
+            panic.app_version
+        };
+
         let payload = slack::WebhookBody::new(|w| {
             w.add_section(|s| s.text(slack::Text::markdown("Panic request".to_string())))
                 .add_section(|s| {
-                    s.add_field(slack::Text::markdown(format!(
-                        "*Version:*\n {} ",
-                        panic.app_version
-                    )))
-                    .add_field({
-                        let hostname = app.config.blob_store_url.clone().unwrap_or_default();
-                        let hostname = hostname.strip_prefix("https://").unwrap_or_else(|| {
-                            hostname.strip_prefix("http://").unwrap_or_default()
-                        });
+                    s.add_field(slack::Text::markdown(format!("*Version:*\n {version} ",)))
+                        .add_field({
+                            let hostname = app.config.blob_store_url.clone().unwrap_or_default();
+                            let hostname = hostname.strip_prefix("https://").unwrap_or_else(|| {
+                                hostname.strip_prefix("http://").unwrap_or_default()
+                            });
 
-                        slack::Text::markdown(format!(
-                            "*{} {}:*\n<https://{}.{}/{}.json|{}…>",
-                            panic.os_name,
-                            panic.os_version.unwrap_or_default(),
-                            CRASH_REPORTS_BUCKET,
-                            hostname,
-                            incident_id,
-                            incident_id.chars().take(8).collect::<String>(),
-                        ))
-                    })
+                            slack::Text::markdown(format!(
+                                "*{} {}:*\n<https://{}.{}/{}.json|{}…>",
+                                panic.os_name,
+                                panic.os_version.unwrap_or_default(),
+                                CRASH_REPORTS_BUCKET,
+                                hostname,
+                                incident_id,
+                                incident_id.chars().take(8).collect::<String>(),
+                            ))
+                        })
                 })
                 .add_rich_text(|r| r.add_preformatted(|p| p.add_text(backtrace_with_summary)))
         });

crates/collab/src/stripe_billing.rs

@@ -11,8 +11,8 @@ use crate::Result;
 use crate::db::billing_subscription::SubscriptionKind;
 use crate::llm::AGENT_EXTENDED_TRIAL_FEATURE_FLAG;
 use crate::stripe_client::{
-    RealStripeClient, StripeBillingAddressCollection, StripeCheckoutSessionMode,
-    StripeCheckoutSessionPaymentMethodCollection, StripeClient,
+    RealStripeClient, StripeAutomaticTax, StripeBillingAddressCollection,
+    StripeCheckoutSessionMode, StripeCheckoutSessionPaymentMethodCollection, StripeClient,
     StripeCreateCheckoutSessionLineItems, StripeCreateCheckoutSessionParams,
     StripeCreateCheckoutSessionSubscriptionData, StripeCreateMeterEventParams,
     StripeCreateMeterEventPayload, StripeCreateSubscriptionItems, StripeCreateSubscriptionParams,
@@ -344,6 +344,7 @@ impl StripeBilling {
                 price: Some(zed_free_price_id),
                 quantity: Some(1),
             }],
+            automatic_tax: Some(StripeAutomaticTax { enabled: true }),
         };
 
         let subscription = self.client.create_subscription(params).await?;

crates/collab/src/stripe_client.rs

@@ -73,6 +73,7 @@ pub enum StripeCancellationDetailsReason {
 pub struct StripeCreateSubscriptionParams {
     pub customer: StripeCustomerId,
     pub items: Vec<StripeCreateSubscriptionItems>,
+    pub automatic_tax: Option<StripeAutomaticTax>,
 }
 
 #[derive(Debug)]
@@ -224,6 +225,11 @@ pub struct StripeTaxIdCollection {
     pub enabled: bool,
 }
 
+#[derive(Debug, Clone)]
+pub struct StripeAutomaticTax {
+    pub enabled: bool,
+}
+
 #[derive(Debug)]
 pub struct StripeCheckoutSession {
     pub url: Option<String>,

crates/collab/src/stripe_client/real_stripe_client.rs

@@ -10,16 +10,17 @@ use stripe::{
     CreateCheckoutSessionSubscriptionData, CreateCheckoutSessionSubscriptionDataTrialSettings,
     CreateCheckoutSessionSubscriptionDataTrialSettingsEndBehavior,
     CreateCheckoutSessionSubscriptionDataTrialSettingsEndBehaviorMissingPaymentMethod,
-    CreateCustomer, Customer, CustomerId, ListCustomers, Price, PriceId, Recurring, Subscription,
-    SubscriptionId, SubscriptionItem, SubscriptionItemId, UpdateCustomer, UpdateSubscriptionItems,
-    UpdateSubscriptionTrialSettings, UpdateSubscriptionTrialSettingsEndBehavior,
+    CreateCustomer, CreateSubscriptionAutomaticTax, Customer, CustomerId, ListCustomers, Price,
+    PriceId, Recurring, Subscription, SubscriptionId, SubscriptionItem, SubscriptionItemId,
+    UpdateCustomer, UpdateSubscriptionItems, UpdateSubscriptionTrialSettings,
+    UpdateSubscriptionTrialSettingsEndBehavior,
     UpdateSubscriptionTrialSettingsEndBehaviorMissingPaymentMethod,
 };
 
 use crate::stripe_client::{
-    CreateCustomerParams, StripeBillingAddressCollection, StripeCancellationDetails,
-    StripeCancellationDetailsReason, StripeCheckoutSession, StripeCheckoutSessionMode,
-    StripeCheckoutSessionPaymentMethodCollection, StripeClient,
+    CreateCustomerParams, StripeAutomaticTax, StripeBillingAddressCollection,
+    StripeCancellationDetails, StripeCancellationDetailsReason, StripeCheckoutSession,
+    StripeCheckoutSessionMode, StripeCheckoutSessionPaymentMethodCollection, StripeClient,
     StripeCreateCheckoutSessionLineItems, StripeCreateCheckoutSessionParams,
     StripeCreateCheckoutSessionSubscriptionData, StripeCreateMeterEventParams,
     StripeCreateSubscriptionParams, StripeCustomer, StripeCustomerId, StripeCustomerUpdate,
@@ -151,6 +152,7 @@ impl StripeClient for RealStripeClient {
                 })
                 .collect(),
         );
+        create_subscription.automatic_tax = params.automatic_tax.map(Into::into);
 
         let subscription = Subscription::create(&self.client, create_subscription).await?;
 
@@ -366,6 +368,15 @@ impl From<SubscriptionItem> for StripeSubscriptionItem {
     }
 }
 
+impl From<StripeAutomaticTax> for CreateSubscriptionAutomaticTax {
+    fn from(value: StripeAutomaticTax) -> Self {
+        Self {
+            enabled: value.enabled,
+            liability: None,
+        }
+    }
+}
+
 impl From<StripeSubscriptionTrialSettings> for UpdateSubscriptionTrialSettings {
     fn from(value: StripeSubscriptionTrialSettings) -> Self {
         Self {

crates/collab/src/tests/following_tests.rs

@@ -1013,7 +1013,7 @@ async fn test_peers_following_each_other(cx_a: &mut TestAppContext, cx_b: &mut T
     // and some of which were originally opened by client B.
     workspace_b.update_in(cx_b, |workspace, window, cx| {
         workspace.active_pane().update(cx, |pane, cx| {
-            pane.close_inactive_items(&Default::default(), None, window, cx)
+            pane.close_other_items(&Default::default(), None, window, cx)
                 .detach();
         });
     });

crates/component/src/component_layout.rs

@@ -118,8 +118,8 @@ impl RenderOnce for ComponentExampleGroup {
                         .flex()
                         .items_center()
                         .gap_3()
-                        .pb_1()
-                        .child(div().h_px().w_4().bg(cx.theme().colors().border))
+                        .mt_4()
+                        .mb_1()
                         .child(
                             div()
                                 .flex_none()

crates/context_server/Cargo.toml

@@ -21,12 +21,14 @@ collections.workspace = true
 futures.workspace = true
 gpui.workspace = true
 log.workspace = true
+net.workspace = true
 parking_lot.workspace = true
 postage.workspace = true
 schemars.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 smol.workspace = true
+tempfile.workspace = true
 url = { workspace = true, features = ["serde"] }
 util.workspace = true
 workspace-hack.workspace = true

crates/context_server/src/client.rs

@@ -70,12 +70,12 @@ fn is_null_value<T: Serialize>(value: &T) -> bool {
 }
 
 #[derive(Serialize, Deserialize)]
-struct Request<'a, T> {
-    jsonrpc: &'static str,
-    id: RequestId,
-    method: &'a str,
+pub struct Request<'a, T> {
+    pub jsonrpc: &'static str,
+    pub id: RequestId,
+    pub method: &'a str,
     #[serde(skip_serializing_if = "is_null_value")]
-    params: T,
+    pub params: T,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -88,18 +88,18 @@ struct AnyResponse<'a> {
     result: Option<&'a RawValue>,
 }
 
-#[derive(Deserialize)]
+#[derive(Serialize, Deserialize)]
 #[allow(dead_code)]
-struct Response<T> {
-    jsonrpc: &'static str,
-    id: RequestId,
+pub(crate) struct Response<T> {
+    pub jsonrpc: &'static str,
+    pub id: RequestId,
     #[serde(flatten)]
-    value: CspResult<T>,
+    pub value: CspResult<T>,
 }
 
-#[derive(Deserialize)]
+#[derive(Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
-enum CspResult<T> {
+pub(crate) enum CspResult<T> {
     #[serde(rename = "result")]
     Ok(Option<T>),
     #[allow(dead_code)]
@@ -123,8 +123,9 @@ struct AnyNotification<'a> {
 }
 
 #[derive(Debug, Serialize, Deserialize)]
-struct Error {
-    message: String,
+pub(crate) struct Error {
+    pub message: String,
+    pub code: i32,
 }
 
 #[derive(Debug, Clone, Deserialize)]

crates/context_server/src/context_server.rs

@@ -1,4 +1,5 @@
 pub mod client;
+pub mod listener;
 pub mod protocol;
 #[cfg(any(test, feature = "test-support"))]
 pub mod test;

crates/context_server/src/listener.rs

@@ -0,0 +1,236 @@
+use ::serde::{Deserialize, Serialize};
+use anyhow::{Context as _, Result};
+use collections::HashMap;
+use futures::{
+    AsyncBufReadExt, AsyncRead, AsyncWrite, AsyncWriteExt, FutureExt,
+    channel::mpsc::{UnboundedReceiver, UnboundedSender, unbounded},
+    io::BufReader,
+    select_biased,
+};
+use gpui::{App, AppContext, AsyncApp, Task};
+use net::async_net::{UnixListener, UnixStream};
+use serde_json::{json, value::RawValue};
+use smol::stream::StreamExt;
+use std::{
+    cell::RefCell,
+    path::{Path, PathBuf},
+    rc::Rc,
+};
+use util::ResultExt;
+
+use crate::{
+    client::{CspResult, RequestId, Response},
+    types::Request,
+};
+
+pub struct McpServer {
+    socket_path: PathBuf,
+    handlers: Rc<RefCell<HashMap<&'static str, McpHandler>>>,
+    _server_task: Task<()>,
+}
+
+type McpHandler = Box<dyn Fn(RequestId, Option<Box<RawValue>>, &App) -> Task<String>>;
+
+impl McpServer {
+    pub fn new(cx: &AsyncApp) -> Task<Result<Self>> {
+        let task = cx.background_spawn(async move {
+            let temp_dir = tempfile::Builder::new().prefix("zed-mcp").tempdir()?;
+            let socket_path = temp_dir.path().join("mcp.sock");
+            let listener = UnixListener::bind(&socket_path).context("creating mcp socket")?;
+
+            anyhow::Ok((temp_dir, socket_path, listener))
+        });
+
+        cx.spawn(async move |cx| {
+            let (temp_dir, socket_path, listener) = task.await?;
+            let handlers = Rc::new(RefCell::new(HashMap::default()));
+            let server_task = cx.spawn({
+                let handlers = handlers.clone();
+                async move |cx| {
+                    while let Ok((stream, _)) = listener.accept().await {
+                        Self::serve_connection(stream, handlers.clone(), cx);
+                    }
+                    drop(temp_dir)
+                }
+            });
+            Ok(Self {
+                socket_path,
+                _server_task: server_task,
+                handlers: handlers.clone(),
+            })
+        })
+    }
+
+    pub fn handle_request<R: Request>(
+        &mut self,
+        f: impl Fn(R::Params, &App) -> Task<Result<R::Response>> + 'static,
+    ) {
+        let f = Box::new(f);
+        self.handlers.borrow_mut().insert(
+            R::METHOD,
+            Box::new(move |req_id, opt_params, cx| {
+                let result = match opt_params {
+                    Some(params) => serde_json::from_str(params.get()),
+                    None => serde_json::from_value(serde_json::Value::Null),
+                };
+
+                let params: R::Params = match result {
+                    Ok(params) => params,
+                    Err(e) => {
+                        return Task::ready(
+                            serde_json::to_string(&Response::<R::Response> {
+                                jsonrpc: "2.0",
+                                id: req_id,
+                                value: CspResult::Error(Some(crate::client::Error {
+                                    message: format!("{e}"),
+                                    code: -32700,
+                                })),
+                            })
+                            .unwrap(),
+                        );
+                    }
+                };
+                let task = f(params, cx);
+                cx.background_spawn(async move {
+                    match task.await {
+                        Ok(result) => serde_json::to_string(&Response {
+                            jsonrpc: "2.0",
+                            id: req_id,
+                            value: CspResult::Ok(Some(result)),
+                        })
+                        .unwrap(),
+                        Err(e) => serde_json::to_string(&Response {
+                            jsonrpc: "2.0",
+                            id: req_id,
+                            value: CspResult::Error::<R::Response>(Some(crate::client::Error {
+                                message: format!("{e}"),
+                                code: -32603,
+                            })),
+                        })
+                        .unwrap(),
+                    }
+                })
+            }),
+        );
+    }
+
+    pub fn socket_path(&self) -> &Path {
+        &self.socket_path
+    }
+
+    fn serve_connection(
+        stream: UnixStream,
+        handlers: Rc<RefCell<HashMap<&'static str, McpHandler>>>,
+        cx: &mut AsyncApp,
+    ) {
+        let (read, write) = smol::io::split(stream);
+        let (incoming_tx, mut incoming_rx) = unbounded();
+        let (outgoing_tx, outgoing_rx) = unbounded();
+
+        cx.background_spawn(Self::handle_io(outgoing_rx, incoming_tx, write, read))
+            .detach();
+
+        cx.spawn(async move |cx| {
+            while let Some(request) = incoming_rx.next().await {
+                let Some(request_id) = request.id.clone() else {
+                    continue;
+                };
+                if let Some(handler) = handlers.borrow().get(&request.method.as_ref()) {
+                    let outgoing_tx = outgoing_tx.clone();
+
+                    if let Some(task) = cx
+                        .update(|cx| handler(request_id, request.params, cx))
+                        .log_err()
+                    {
+                        cx.spawn(async move |_| {
+                            let response = task.await;
+                            outgoing_tx.unbounded_send(response).ok();
+                        })
+                        .detach();
+                    }
+                } else {
+                    outgoing_tx
+                        .unbounded_send(
+                            serde_json::to_string(&Response::<()> {
+                                jsonrpc: "2.0",
+                                id: request.id.unwrap(),
+                                value: CspResult::Error(Some(crate::client::Error {
+                                    message: format!("unhandled method {}", request.method),
+                                    code: -32601,
+                                })),
+                            })
+                            .unwrap(),
+                        )
+                        .ok();
+                }
+            }
+        })
+        .detach();
+    }
+
+    async fn handle_io(
+        mut outgoing_rx: UnboundedReceiver<String>,
+        incoming_tx: UnboundedSender<RawRequest>,
+        mut outgoing_bytes: impl Unpin + AsyncWrite,
+        incoming_bytes: impl Unpin + AsyncRead,
+    ) -> Result<()> {
+        let mut output_reader = BufReader::new(incoming_bytes);
+        let mut incoming_line = String::new();
+        loop {
+            select_biased! {
+                message = outgoing_rx.next().fuse() => {
+                    if let Some(message) = message {
+                        log::trace!("send: {}", &message);
+                        outgoing_bytes.write_all(message.as_bytes()).await?;
+                        outgoing_bytes.write_all(&[b'\n']).await?;
+                    } else {
+                        break;
+                    }
+                }
+                bytes_read = output_reader.read_line(&mut incoming_line).fuse() => {
+                    if bytes_read? == 0 {
+                        break
+                    }
+                    log::trace!("recv: {}", &incoming_line);
+                    match serde_json::from_str(&incoming_line) {
+                        Ok(message) => {
+                            incoming_tx.unbounded_send(message).log_err();
+                        }
+                        Err(error) => {
+                            outgoing_bytes.write_all(serde_json::to_string(&json!({
+                                "jsonrpc": "2.0",
+                                "error": json!({
+                                    "code": -32603,
+                                    "message": format!("Failed to parse: {error}"),
+                                }),
+                            }))?.as_bytes()).await?;
+                            outgoing_bytes.write_all(&[b'\n']).await?;
+                            log::error!("failed to parse incoming message: {error}. Raw: {incoming_line}");
+                        }
+                    }
+                    incoming_line.clear();
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+#[derive(Serialize, Deserialize)]
+struct RawRequest {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    id: Option<RequestId>,
+    method: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    params: Option<Box<serde_json::value::RawValue>>,
+}
+
+#[derive(Serialize, Deserialize)]
+struct RawResponse {
+    jsonrpc: &'static str,
+    id: RequestId,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    error: Option<crate::client::Error>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    result: Option<Box<serde_json::value::RawValue>>,
+}

crates/context_server/src/types.rs

@@ -153,7 +153,7 @@ pub struct InitializeParams {
 pub struct CallToolParams {
     pub name: String,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub arguments: Option<HashMap<String, serde_json::Value>>,
+    pub arguments: Option<serde_json::Value>,
     #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
     pub meta: Option<HashMap<String, serde_json::Value>>,
 }

crates/copilot/src/copilot.rs

@@ -209,8 +209,14 @@ impl Status {
         matches!(self, Status::Authorized)
     }
 
-    pub fn is_disabled(&self) -> bool {
-        matches!(self, Status::Disabled)
+    pub fn is_configured(&self) -> bool {
+        matches!(
+            self,
+            Status::Starting { .. }
+                | Status::Error(_)
+                | Status::SigningIn { .. }
+                | Status::Authorized
+        )
     }
 }
 

crates/dap_adapters/Cargo.toml

@@ -36,6 +36,7 @@ paths.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 shlex.workspace = true
+smol.workspace = true
 task.workspace = true
 util.workspace = true
 workspace-hack.workspace = true

crates/dap_adapters/src/dap_adapters.rs

@@ -13,7 +13,6 @@ use dap::{
     DapRegistry,
     adapters::{
         self, AdapterVersion, DapDelegate, DebugAdapter, DebugAdapterBinary, DebugAdapterName,
-        GithubRepo,
     },
     configure_tcp_connection,
 };

crates/dap_adapters/src/python.rs

@@ -1,31 +1,39 @@
 use crate::*;
 use anyhow::Context as _;
-use dap::adapters::latest_github_release;
 use dap::{DebugRequest, StartDebuggingRequestArguments, adapters::DebugTaskDefinition};
-use gpui::{AppContext, AsyncApp, SharedString};
+use gpui::{AsyncApp, SharedString};
 use json_dotpath::DotPaths;
-use language::{LanguageName, Toolchain};
+use language::LanguageName;
+use paths::debug_adapters_dir;
 use serde_json::Value;
+use smol::lock::OnceCell;
 use std::net::Ipv4Addr;
 use std::{
     collections::HashMap,
     ffi::OsStr,
     path::{Path, PathBuf},
-    sync::OnceLock,
 };
-use util::ResultExt;
 
 #[derive(Default)]
 pub(crate) struct PythonDebugAdapter {
-    checked: OnceLock<()>,
+    python_venv_base: OnceCell<Result<Arc<Path>, String>>,
 }
 
 impl PythonDebugAdapter {
     const ADAPTER_NAME: &'static str = "Debugpy";
     const DEBUG_ADAPTER_NAME: DebugAdapterName =
         DebugAdapterName(SharedString::new_static(Self::ADAPTER_NAME));
-    const ADAPTER_PACKAGE_NAME: &'static str = "debugpy";
-    const ADAPTER_PATH: &'static str = "src/debugpy/adapter";
+    const PYTHON_ADAPTER_IN_VENV: &'static str = if cfg!(target_os = "windows") {
+        "Scripts/python3"
+    } else {
+        "bin/python3"
+    };
+    const ADAPTER_PATH: &'static str = if cfg!(target_os = "windows") {
+        "debugpy-venv/Scripts/debugpy-adapter"
+    } else {
+        "debugpy-venv/bin/debugpy-adapter"
+    };
+
     const LANGUAGE_NAME: &'static str = "Python";
 
     async fn generate_debugpy_arguments(
@@ -46,25 +54,12 @@ impl PythonDebugAdapter {
             vec!["-m".to_string(), "debugpy.adapter".to_string()]
         } else {
             let adapter_path = paths::debug_adapters_dir().join(Self::DEBUG_ADAPTER_NAME.as_ref());
-            let file_name_prefix = format!("{}_", Self::ADAPTER_NAME);
-
-            let debugpy_dir =
-                util::fs::find_file_name_in_dir(adapter_path.as_path(), |file_name| {
-                    file_name.starts_with(&file_name_prefix)
-                })
-                .await
-                .context("Debugpy directory not found")?;
-
-            log::debug!(
-                "Using GitHub-downloaded debugpy adapter from: {}",
-                debugpy_dir.display()
-            );
-            vec![
-                debugpy_dir
-                    .join(Self::ADAPTER_PATH)
-                    .to_string_lossy()
-                    .to_string(),
-            ]
+            let path = adapter_path
+                .join(Self::ADAPTER_PATH)
+                .to_string_lossy()
+                .into_owned();
+            log::debug!("Using pip debugpy adapter from: {path}");
+            vec![path]
         };
 
         args.extend(if let Some(args) = user_args {
@@ -100,44 +95,67 @@ impl PythonDebugAdapter {
             request,
         })
     }
-    async fn fetch_latest_adapter_version(
-        &self,
-        delegate: &Arc<dyn DapDelegate>,
-    ) -> Result<AdapterVersion> {
-        let github_repo = GithubRepo {
-            repo_name: Self::ADAPTER_PACKAGE_NAME.into(),
-            repo_owner: "microsoft".into(),
-        };
 
-        fetch_latest_adapter_version_from_github(github_repo, delegate.as_ref()).await
-    }
-
-    async fn install_binary(
-        adapter_name: DebugAdapterName,
-        version: AdapterVersion,
-        delegate: Arc<dyn DapDelegate>,
-    ) -> Result<()> {
-        let version_path = adapters::download_adapter_from_github(
-            adapter_name,
-            version,
-            adapters::DownloadedFileType::GzipTar,
-            delegate.as_ref(),
-        )
-        .await?;
-        // only needed when you install the latest version for the first time
-        if let Some(debugpy_dir) =
-            util::fs::find_file_name_in_dir(version_path.as_path(), |file_name| {
-                file_name.starts_with("microsoft-debugpy-")
-            })
+    async fn ensure_venv(delegate: &dyn DapDelegate) -> Result<Arc<Path>> {
+        let python_path = Self::find_base_python(delegate)
             .await
-        {
-            // TODO Debugger: Rename folder instead of moving all files to another folder
-            // We're doing unnecessary IO work right now
-            util::fs::move_folder_files_to_folder(debugpy_dir.as_path(), version_path.as_path())
+            .context("Could not find Python installation for DebugPy")?;
+        let work_dir = debug_adapters_dir().join(Self::ADAPTER_NAME);
+        let mut path = work_dir.clone();
+        path.push("debugpy-venv");
+        if !path.exists() {
+            util::command::new_smol_command(python_path)
+                .arg("-m")
+                .arg("venv")
+                .arg("debugpy-venv")
+                .current_dir(work_dir)
+                .spawn()?
+                .output()
                 .await?;
         }
 
-        Ok(())
+        Ok(path.into())
+    }
+
+    // Find "baseline", user python version from which we'll create our own venv.
+    async fn find_base_python(delegate: &dyn DapDelegate) -> Option<PathBuf> {
+        for path in ["python3", "python"] {
+            if let Some(path) = delegate.which(path.as_ref()).await {
+                return Some(path);
+            }
+        }
+        None
+    }
+
+    async fn base_venv(&self, delegate: &dyn DapDelegate) -> Result<Arc<Path>, String> {
+        const BINARY_DIR: &str = if cfg!(target_os = "windows") {
+            "Scripts"
+        } else {
+            "bin"
+        };
+        self.python_venv_base
+            .get_or_init(move || async move {
+                let venv_base = Self::ensure_venv(delegate)
+                    .await
+                    .map_err(|e| format!("{e}"))?;
+                let pip_path = venv_base.join(BINARY_DIR).join("pip3");
+                let installation_succeeded = util::command::new_smol_command(pip_path.as_path())
+                    .arg("install")
+                    .arg("debugpy")
+                    .arg("-U")
+                    .output()
+                    .await
+                    .map_err(|e| format!("{e}"))?
+                    .status
+                    .success();
+                if !installation_succeeded {
+                    return Err("debugpy installation failed".into());
+                }
+
+                Ok(venv_base)
+            })
+            .await
+            .clone()
     }
 
     async fn get_installed_binary(
@@ -146,15 +164,15 @@ impl PythonDebugAdapter {
         config: &DebugTaskDefinition,
         user_installed_path: Option<PathBuf>,
         user_args: Option<Vec<String>>,
-        toolchain: Option<Toolchain>,
+        python_from_toolchain: Option<String>,
         installed_in_venv: bool,
     ) -> Result<DebugAdapterBinary> {
         const BINARY_NAMES: [&str; 3] = ["python3", "python", "py"];
         let tcp_connection = config.tcp_connection.clone().unwrap_or_default();
         let (host, port, timeout) = crate::configure_tcp_connection(tcp_connection).await?;
 
-        let python_path = if let Some(toolchain) = toolchain {
-            Some(toolchain.path.to_string())
+        let python_path = if let Some(toolchain) = python_from_toolchain {
+            Some(toolchain)
         } else {
             let mut name = None;
 
@@ -635,25 +653,28 @@ impl DebugAdapter for PythonDebugAdapter {
                             &config,
                             None,
                             user_args,
-                            Some(toolchain.clone()),
+                            Some(toolchain.path.to_string()),
                             true,
                         )
                         .await;
                 }
             }
         }
-
-        if self.checked.set(()).is_ok() {
-            delegate.output_to_console(format!("Checking latest version of {}...", self.name()));
-            if let Some(version) = self.fetch_latest_adapter_version(delegate).await.log_err() {
-                cx.background_spawn(Self::install_binary(self.name(), version, delegate.clone()))
-                    .await
-                    .context("Failed to install debugpy")?;
-            }
-        }
-
-        self.get_installed_binary(delegate, &config, None, user_args, toolchain, false)
+        let toolchain = self
+            .base_venv(&**delegate)
             .await
+            .map_err(|e| anyhow::anyhow!(e))?
+            .join(Self::PYTHON_ADAPTER_IN_VENV);
+
+        self.get_installed_binary(
+            delegate,
+            &config,
+            None,
+            user_args,
+            Some(toolchain.to_string_lossy().into_owned()),
+            false,
+        )
+        .await
     }
 
     fn label_for_child_session(&self, args: &StartDebuggingRequestArguments) -> Option<String> {
@@ -666,24 +687,6 @@ impl DebugAdapter for PythonDebugAdapter {
     }
 }
 
-async fn fetch_latest_adapter_version_from_github(
-    github_repo: GithubRepo,
-    delegate: &dyn DapDelegate,
-) -> Result<AdapterVersion> {
-    let release = latest_github_release(
-        &format!("{}/{}", github_repo.repo_owner, github_repo.repo_name),
-        false,
-        false,
-        delegate.http_client(),
-    )
-    .await?;
-
-    Ok(AdapterVersion {
-        tag_name: release.tag_name,
-        url: release.tarball_url,
-    })
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

crates/debugger_ui/Cargo.toml

@@ -35,6 +35,7 @@ command_palette_hooks.workspace = true
 dap.workspace = true
 dap_adapters = { workspace = true, optional = true }
 db.workspace = true
+debugger_tools.workspace = true
 editor.workspace = true
 file_icons.workspace = true
 futures.workspace = true
@@ -54,6 +55,7 @@ picker.workspace = true
 pretty_assertions.workspace = true
 project.workspace = true
 rpc.workspace = true
+schemars.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 serde_json_lenient.workspace = true
@@ -66,14 +68,13 @@ telemetry.workspace = true
 terminal_view.workspace = true
 text.workspace = true
 theme.workspace = true
-tree-sitter.workspace = true
 tree-sitter-json.workspace = true
+tree-sitter.workspace = true
 ui.workspace = true
-util.workspace = true
-workspace.workspace = true
-workspace-hack.workspace = true
-debugger_tools.workspace = true
 unindent = { workspace = true, optional = true }
+util.workspace = true
+workspace-hack.workspace = true
+workspace.workspace = true
 zed_actions.workspace = true
 
 [dev-dependencies]
@@ -83,8 +84,8 @@ debugger_tools = { workspace = true, features = ["test-support"] }
 editor = { workspace = true, features = ["test-support"] }
 gpui = { workspace = true, features = ["test-support"] }
 project = { workspace = true, features = ["test-support"] }
+tree-sitter-go.workspace = true
 unindent.workspace = true
 util = { workspace = true, features = ["test-support"] }
 workspace = { workspace = true, features = ["test-support"] }
 zlog.workspace = true
-tree-sitter-go.workspace = true

crates/debugger_ui/src/debugger_ui.rs

@@ -3,10 +3,12 @@ use std::any::TypeId;
 use dap::debugger_settings::DebuggerSettings;
 use debugger_panel::DebugPanel;
 use editor::Editor;
-use gpui::{App, DispatchPhase, EntityInputHandler, actions};
+use gpui::{Action, App, DispatchPhase, EntityInputHandler, actions};
 use new_process_modal::{NewProcessModal, NewProcessMode};
 use onboarding_modal::DebuggerOnboardingModal;
 use project::debugger::{self, breakpoint_store::SourceBreakpoint, session::ThreadStatus};
+use schemars::JsonSchema;
+use serde::Deserialize;
 use session::DebugSession;
 use settings::Settings;
 use stack_trace_view::StackTraceView;
@@ -83,11 +85,23 @@ actions!(
         Rerun,
         /// Toggles expansion of the selected item in the debugger UI.
         ToggleExpandItem,
-        /// Set a data breakpoint on the selected variable or memory region.
-        ToggleDataBreakpoint,
     ]
 );
 
+/// Extends selection down by a specified number of lines.
+#[derive(PartialEq, Clone, Deserialize, Default, JsonSchema, Action)]
+#[action(namespace = debugger)]
+#[serde(deny_unknown_fields)]
+/// Set a data breakpoint on the selected variable or memory region.
+pub struct ToggleDataBreakpoint {
+    /// The type of data breakpoint
+    /// Read & Write
+    /// Read
+    /// Write
+    #[serde(default)]
+    pub access_type: Option<dap::DataBreakpointAccessType>,
+}
+
 actions!(
     dev,
     [

crates/debugger_ui/src/session/running/memory_view.rs

@@ -688,7 +688,7 @@ impl MemoryView {
                 menu = menu.action_disabled_when(
                     *memory_unreadable,
                     "Set Data Breakpoint",
-                    ToggleDataBreakpoint.boxed_clone(),
+                    ToggleDataBreakpoint { access_type: None }.boxed_clone(),
                 );
             }
             menu.context(self.focus_handle.clone())

crates/debugger_ui/src/session/running/variable_list.rs

@@ -670,9 +670,9 @@ impl VariableList {
         let focus_handle = self.focus_handle.clone();
         cx.spawn_in(window, async move |this, cx| {
             let can_toggle_data_breakpoint = if let Some(task) = can_toggle_data_breakpoint {
-                task.await.is_some()
+                task.await
             } else {
-                true
+                None
             };
             cx.update(|window, cx| {
                 let context_menu = ContextMenu::build(window, cx, |menu, _, _| {
@@ -686,11 +686,35 @@ impl VariableList {
                                 menu.action("Go To Memory", GoToMemory.boxed_clone())
                             })
                             .action("Watch Variable", AddWatch.boxed_clone())
-                            .when(can_toggle_data_breakpoint, |menu| {
-                                menu.action(
-                                    "Toggle Data Breakpoint",
-                                    crate::ToggleDataBreakpoint.boxed_clone(),
-                                )
+                            .when_some(can_toggle_data_breakpoint, |mut menu, data_info| {
+                                menu = menu.separator();
+                                if let Some(access_types) = data_info.access_types {
+                                    for access in access_types {
+                                        menu = menu.action(
+                                            format!(
+                                                "Toggle {} Data Breakpoint",
+                                                match access {
+                                                    dap::DataBreakpointAccessType::Read => "Read",
+                                                    dap::DataBreakpointAccessType::Write => "Write",
+                                                    dap::DataBreakpointAccessType::ReadWrite =>
+                                                        "Read/Write",
+                                                }
+                                            ),
+                                            crate::ToggleDataBreakpoint {
+                                                access_type: Some(access),
+                                            }
+                                            .boxed_clone(),
+                                        );
+                                    }
+
+                                    menu
+                                } else {
+                                    menu.action(
+                                        "Toggle Data Breakpoint",
+                                        crate::ToggleDataBreakpoint { access_type: None }
+                                            .boxed_clone(),
+                                    )
+                                }
                             })
                     })
                     .when(entry.as_watcher().is_some(), |menu| {
@@ -729,7 +753,7 @@ impl VariableList {
 
     fn toggle_data_breakpoint(
         &mut self,
-        _: &crate::ToggleDataBreakpoint,
+        data_info: &crate::ToggleDataBreakpoint,
         _window: &mut Window,
         cx: &mut Context<Self>,
     ) {
@@ -759,17 +783,34 @@ impl VariableList {
         });
 
         let session = self.session.downgrade();
+        let access_type = data_info.access_type;
         cx.spawn(async move |_, cx| {
-            let Some(data_id) = data_breakpoint.await.and_then(|info| info.data_id) else {
+            let Some((data_id, access_types)) = data_breakpoint
+                .await
+                .and_then(|info| Some((info.data_id?, info.access_types)))
+            else {
                 return;
             };
+
+            // Because user's can manually add this action to the keymap
+            // we check if access type is supported
+            let access_type = match access_types {
+                None => None,
+                Some(access_types) => {
+                    if access_type.is_some_and(|access_type| access_types.contains(&access_type)) {
+                        access_type
+                    } else {
+                        None
+                    }
+                }
+            };
             _ = session.update(cx, |session, cx| {
                 session.create_data_breakpoint(
                     context,
                     data_id.clone(),
                     dap::DataBreakpoint {
                         data_id,
-                        access_type: None,
+                        access_type,
                         condition: None,
                         hit_condition: None,
                     },

crates/editor/src/code_context_menus.rs

@@ -1074,6 +1074,20 @@ impl CompletionsMenu {
             .and_then(|q| q.chars().next())
             .and_then(|c| c.to_lowercase().next());
 
+        if snippet_sort_order == SnippetSortOrder::None {
+            matches.retain(|string_match| {
+                let completion = &completions[string_match.candidate_id];
+
+                let is_snippet = matches!(
+                    &completion.source,
+                    CompletionSource::Lsp { lsp_completion, .. }
+                    if lsp_completion.kind == Some(CompletionItemKind::SNIPPET)
+                );
+
+                !is_snippet
+            });
+        }
+
         matches.sort_unstable_by_key(|string_match| {
             let completion = &completions[string_match.candidate_id];
 
@@ -1112,6 +1126,7 @@ impl CompletionsMenu {
                     SnippetSortOrder::Top => Reverse(if is_snippet { 1 } else { 0 }),
                     SnippetSortOrder::Bottom => Reverse(if is_snippet { 0 } else { 1 }),
                     SnippetSortOrder::Inline => Reverse(0),
+                    SnippetSortOrder::None => Reverse(0),
                 };
                 let sort_positions = string_match.positions.clone();
                 let sort_exact = Reverse(if Some(completion.label.filter_text()) == query {
@@ -1369,7 +1384,7 @@ impl CodeActionsMenu {
         }
     }
 
-    fn visible(&self) -> bool {
+    pub fn visible(&self) -> bool {
         !self.actions.is_empty()
     }
 

crates/editor/src/editor.rs

@@ -2382,13 +2382,17 @@ impl Editor {
         }
 
         match self.context_menu.borrow().as_ref() {
-            Some(CodeContextMenu::Completions(_)) => {
-                key_context.add("menu");
-                key_context.add("showing_completions");
+            Some(CodeContextMenu::Completions(menu)) => {
+                if menu.visible() {
+                    key_context.add("menu");
+                    key_context.add("showing_completions");
+                }
             }
-            Some(CodeContextMenu::CodeActions(_)) => {
-                key_context.add("menu");
-                key_context.add("showing_code_actions")
+            Some(CodeContextMenu::CodeActions(menu)) => {
+                if menu.visible() {
+                    key_context.add("menu");
+                    key_context.add("showing_code_actions")
+                }
             }
             None => {}
         }
@@ -5447,7 +5451,7 @@ impl Editor {
         };
 
         let (word_replace_range, word_to_exclude) = if let (word_range, Some(CharKind::Word)) =
-            buffer_snapshot.surrounding_word(buffer_position)
+            buffer_snapshot.surrounding_word(buffer_position, false)
         {
             let word_to_exclude = buffer_snapshot
                 .text_for_range(word_range.clone())
@@ -6601,8 +6605,8 @@ impl Editor {
         }
 
         let snapshot = cursor_buffer.read(cx).snapshot();
-        let (start_word_range, _) = snapshot.surrounding_word(cursor_buffer_position);
-        let (end_word_range, _) = snapshot.surrounding_word(tail_buffer_position);
+        let (start_word_range, _) = snapshot.surrounding_word(cursor_buffer_position, false);
+        let (end_word_range, _) = snapshot.surrounding_word(tail_buffer_position, false);
         if start_word_range != end_word_range {
             self.document_highlights_task.take();
             self.clear_background_highlights::<DocumentHighlightRead>(cx);
@@ -22133,7 +22137,7 @@ impl SemanticsProvider for Entity<Project> {
                         // Fallback on using TreeSitter info to determine identifier range
                         buffer.read_with(cx, |buffer, _| {
                             let snapshot = buffer.snapshot();
-                            let (range, kind) = snapshot.surrounding_word(position);
+                            let (range, kind) = snapshot.surrounding_word(position, false);
                             if kind != Some(CharKind::Word) {
                                 return None;
                             }

crates/editor/src/editor_settings.rs

@@ -395,6 +395,8 @@ pub enum SnippetSortOrder {
     Inline,
     /// Place snippets at the bottom of the completion list
     Bottom,
+    /// Do not show snippets in the completion list
+    None,
 }
 
 #[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]

crates/editor/src/editor_tests.rs

@@ -55,7 +55,7 @@ use util::{
     uri,
 };
 use workspace::{
-    CloseActiveItem, CloseAllItems, CloseInactiveItems, MoveItemToPaneInDirection, NavigationEntry,
+    CloseActiveItem, CloseAllItems, CloseOtherItems, MoveItemToPaneInDirection, NavigationEntry,
     OpenOptions, ViewId,
     item::{FollowEvent, FollowableItem, Item, ItemHandle, SaveOptions},
 };
@@ -21463,7 +21463,7 @@ println!("5");
         .unwrap();
     pane_1
         .update_in(cx, |pane, window, cx| {
-            pane.close_inactive_items(&CloseInactiveItems::default(), None, window, cx)
+            pane.close_other_items(&CloseOtherItems::default(), None, window, cx)
         })
         .await
         .unwrap();
@@ -21499,7 +21499,7 @@ println!("5");
         .unwrap();
     pane_2
         .update_in(cx, |pane, window, cx| {
-            pane.close_inactive_items(&CloseInactiveItems::default(), None, window, cx)
+            pane.close_other_items(&CloseOtherItems::default(), None, window, cx)
         })
         .await
         .unwrap();

crates/editor/src/element.rs

@@ -949,6 +949,7 @@ impl EditorElement {
         if !pending_nonempty_selections && hovered_link_modifier && text_hitbox.is_hovered(window) {
             let point = position_map.point_for_position(event.up.position);
             editor.handle_click_hovered_link(point, event.modifiers(), window, cx);
+            editor.selection_drag_state = SelectionDragState::None;
 
             cx.stop_propagation();
         }

crates/editor/src/scroll.rs

@@ -12,7 +12,7 @@ use crate::{
 };
 pub use autoscroll::{Autoscroll, AutoscrollStrategy};
 use core::fmt::Debug;
-use gpui::{App, Axis, Context, Global, Pixels, Task, Window, point, px};
+use gpui::{Along, App, Axis, Context, Global, Pixels, Task, Window, point, px};
 use language::language_settings::{AllLanguageSettings, SoftWrap};
 use language::{Bias, Point};
 pub use scroll_amount::ScrollAmount;
@@ -49,14 +49,14 @@ impl ScrollAnchor {
     }
 
     pub fn scroll_position(&self, snapshot: &DisplaySnapshot) -> gpui::Point<f32> {
-        let mut scroll_position = self.offset;
-        if self.anchor == Anchor::min() {
-            scroll_position.y = 0.;
-        } else {
-            let scroll_top = self.anchor.to_display_point(snapshot).row().as_f32();
-            scroll_position.y += scroll_top;
-        }
-        scroll_position
+        self.offset.apply_along(Axis::Vertical, |offset| {
+            if self.anchor == Anchor::min() {
+                0.
+            } else {
+                let scroll_top = self.anchor.to_display_point(snapshot).row().as_f32();
+                (offset + scroll_top).max(0.)
+            }
+        })
     }
 
     pub fn top_row(&self, buffer: &MultiBufferSnapshot) -> u32 {

crates/eval/src/example.rs

@@ -422,6 +422,13 @@ impl AppContext for ExampleContext {
         self.app.update_entity(handle, update)
     }
 
+    fn as_mut<'a, T>(&'a mut self, handle: &Entity<T>) -> Self::Result<gpui::GpuiBorrow<'a, T>>
+    where
+        T: 'static,
+    {
+        self.app.as_mut(handle)
+    }
+
     fn read_entity<T, R>(
         &self,
         handle: &Entity<T>,

crates/extension_host/src/extension_host.rs

@@ -1313,10 +1313,17 @@ impl ExtensionStore {
                     }
 
                     for snippets_path in &snippets_to_add {
-                        if let Some(snippets_contents) = fs.load(snippets_path).await.log_err() {
-                            proxy
-                                .register_snippet(snippets_path, &snippets_contents)
-                                .log_err();
+                        match fs
+                            .load(snippets_path)
+                            .await
+                            .with_context(|| format!("Loading snippets from {snippets_path:?}"))
+                        {
+                            Ok(snippets_contents) => {
+                                proxy
+                                    .register_snippet(snippets_path, &snippets_contents)
+                                    .log_err();
+                            }
+                            Err(e) => log::error!("Cannot load snippets: {e:#}"),
                         }
                     }
                 }
@@ -1331,20 +1338,25 @@ impl ExtensionStore {
 
                 let extension_path = root_dir.join(extension.manifest.id.as_ref());
                 let wasm_extension = WasmExtension::load(
-                    extension_path,
+                    &extension_path,
                     &extension.manifest,
                     wasm_host.clone(),
                     &cx,
                 )
-                .await;
+                .await
+                .with_context(|| format!("Loading extension from {extension_path:?}"));
 
-                if let Some(wasm_extension) = wasm_extension.log_err() {
-                    wasm_extensions.push((extension.manifest.clone(), wasm_extension));
-                } else {
-                    this.update(cx, |_, cx| {
-                        cx.emit(Event::ExtensionFailedToLoad(extension.manifest.id.clone()))
-                    })
-                    .ok();
+                match wasm_extension {
+                    Ok(wasm_extension) => {
+                        wasm_extensions.push((extension.manifest.clone(), wasm_extension))
+                    }
+                    Err(e) => {
+                        log::error!("Failed to load extension: {e:#}");
+                        this.update(cx, |_, cx| {
+                            cx.emit(Event::ExtensionFailedToLoad(extension.manifest.id.clone()))
+                        })
+                        .ok();
+                    }
                 }
             }
 

crates/extension_host/src/headless_host.rs

@@ -173,9 +173,8 @@ impl HeadlessExtensionStore {
             return Ok(());
         }
 
-        let wasm_extension: Arc<dyn Extension> = Arc::new(
-            WasmExtension::load(extension_dir.clone(), &manifest, wasm_host.clone(), &cx).await?,
-        );
+        let wasm_extension: Arc<dyn Extension> =
+            Arc::new(WasmExtension::load(&extension_dir, &manifest, wasm_host.clone(), &cx).await?);
 
         for (language_server_id, language_server_config) in &manifest.language_servers {
             for language in language_server_config.languages() {

crates/extension_host/src/wasm_host.rs

@@ -715,7 +715,7 @@ fn parse_wasm_extension_version_custom_section(data: &[u8]) -> Option<SemanticVe
 
 impl WasmExtension {
     pub async fn load(
-        extension_dir: PathBuf,
+        extension_dir: &Path,
         manifest: &Arc<ExtensionManifest>,
         wasm_host: Arc<WasmHost>,
         cx: &AsyncApp,

crates/git/src/git.rs

@@ -77,6 +77,8 @@ actions!(
         Commit,
         /// Amends the last commit with staged changes.
         Amend,
+        /// Enable the --signoff option.
+        Signoff,
         /// Cancels the current git operation.
         Cancel,
         /// Expands the commit message editor.

crates/git/src/repository.rs

@@ -96,6 +96,7 @@ impl Upstream {
 #[derive(Clone, Copy, Default)]
 pub struct CommitOptions {
     pub amend: bool,
+    pub signoff: bool,
 }
 
 #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
@@ -1209,6 +1210,10 @@ impl GitRepository for RealGitRepository {
                     cmd.arg("--amend");
                 }
 
+                if options.signoff {
+                    cmd.arg("--signoff");
+                }
+
                 if let Some((name, email)) = name_and_email {
                     cmd.arg("--author").arg(&format!("{name} <{email}>"));
                 }

crates/git_ui/src/commit_modal.rs

@@ -1,8 +1,8 @@
 use crate::branch_picker::{self, BranchList};
 use crate::git_panel::{GitPanel, commit_message_editor};
 use git::repository::CommitOptions;
-use git::{Amend, Commit, GenerateCommitMessage};
-use panel::{panel_button, panel_editor_style, panel_filled_button};
+use git::{Amend, Commit, GenerateCommitMessage, Signoff};
+use panel::{panel_button, panel_editor_style};
 use ui::{
     ContextMenu, KeybindingHint, PopoverMenu, PopoverMenuHandle, SplitButton, Tooltip, prelude::*,
 };
@@ -273,14 +273,51 @@ impl CommitModal {
                             .child(Icon::new(IconName::ChevronDownSmall).size(IconSize::XSmall)),
                     ),
             )
-            .menu(move |window, cx| {
-                Some(ContextMenu::build(window, cx, |context_menu, _, _| {
-                    context_menu
-                        .when_some(keybinding_target.clone(), |el, keybinding_target| {
-                            el.context(keybinding_target.clone())
-                        })
-                        .action("Amend", Amend.boxed_clone())
-                }))
+            .menu({
+                let git_panel_entity = self.git_panel.clone();
+                move |window, cx| {
+                    let git_panel = git_panel_entity.read(cx);
+                    let amend_enabled = git_panel.amend_pending();
+                    let signoff_enabled = git_panel.signoff_enabled();
+                    let has_previous_commit = git_panel.head_commit(cx).is_some();
+
+                    Some(ContextMenu::build(window, cx, |context_menu, _, _| {
+                        context_menu
+                            .when_some(keybinding_target.clone(), |el, keybinding_target| {
+                                el.context(keybinding_target.clone())
+                            })
+                            .when(has_previous_commit, |this| {
+                                this.toggleable_entry(
+                                    "Amend",
+                                    amend_enabled,
+                                    IconPosition::Start,
+                                    Some(Box::new(Amend)),
+                                    {
+                                        let git_panel = git_panel_entity.clone();
+                                        move |window, cx| {
+                                            git_panel.update(cx, |git_panel, cx| {
+                                                git_panel.toggle_amend_pending(&Amend, window, cx);
+                                            })
+                                        }
+                                    },
+                                )
+                            })
+                            .toggleable_entry(
+                                "Signoff",
+                                signoff_enabled,
+                                IconPosition::Start,
+                                Some(Box::new(Signoff)),
+                                {
+                                    let git_panel = git_panel_entity.clone();
+                                    move |window, cx| {
+                                        git_panel.update(cx, |git_panel, cx| {
+                                            git_panel.toggle_signoff_enabled(&Signoff, window, cx);
+                                        })
+                                    }
+                                },
+                            )
+                    }))
+                }
             })
             .with_handle(self.commit_menu_handle.clone())
             .anchor(Corner::TopRight)
@@ -295,7 +332,7 @@ impl CommitModal {
             generate_commit_message,
             active_repo,
             is_amend_pending,
-            has_previous_commit,
+            is_signoff_enabled,
         ) = self.git_panel.update(cx, |git_panel, cx| {
             let (can_commit, tooltip) = git_panel.configure_commit_button(cx);
             let title = git_panel.commit_button_title();
@@ -303,10 +340,7 @@ impl CommitModal {
             let generate_commit_message = git_panel.render_generate_commit_message_button(cx);
             let active_repo = git_panel.active_repository.clone();
             let is_amend_pending = git_panel.amend_pending();
-            let has_previous_commit = active_repo
-                .as_ref()
-                .and_then(|repo| repo.read(cx).head_commit.as_ref())
-                .is_some();
+            let is_signoff_enabled = git_panel.signoff_enabled();
             (
                 can_commit,
                 tooltip,
@@ -315,7 +349,7 @@ impl CommitModal {
                 generate_commit_message,
                 active_repo,
                 is_amend_pending,
-                has_previous_commit,
+                is_signoff_enabled,
             )
         });
 
@@ -396,126 +430,59 @@ impl CommitModal {
                     .px_1()
                     .gap_4()
                     .children(close_kb_hint)
-                    .when(is_amend_pending, |this| {
-                        let focus_handle = focus_handle.clone();
-                        this.child(
-                            panel_filled_button(commit_label)
-                                .tooltip(move |window, cx| {
-                                    if can_commit {
-                                        Tooltip::for_action_in(
-                                            tooltip,
-                                            &Amend,
-                                            &focus_handle,
-                                            window,
-                                            cx,
-                                        )
-                                    } else {
-                                        Tooltip::simple(tooltip, cx)
-                                    }
-                                })
-                                .disabled(!can_commit)
-                                .on_click(cx.listener(move |this, _: &ClickEvent, window, cx| {
-                                    telemetry::event!("Git Amended", source = "Git Modal");
-                                    this.git_panel.update(cx, |git_panel, cx| {
-                                        git_panel.set_amend_pending(false, cx);
-                                        git_panel.commit_changes(
-                                            CommitOptions { amend: true },
-                                            window,
-                                            cx,
-                                        );
-                                    });
-                                    cx.emit(DismissEvent);
-                                })),
+                    .child(SplitButton::new(
+                        ui::ButtonLike::new_rounded_left(ElementId::Name(
+                            format!("split-button-left-{}", commit_label).into(),
+                        ))
+                        .layer(ui::ElevationIndex::ModalSurface)
+                        .size(ui::ButtonSize::Compact)
+                        .child(
+                            div()
+                                .child(Label::new(commit_label).size(LabelSize::Small))
+                                .mr_0p5(),
                         )
-                    })
-                    .when(!is_amend_pending, |this| {
-                        this.when(has_previous_commit, |this| {
-                            this.child(SplitButton::new(
-                                ui::ButtonLike::new_rounded_left(ElementId::Name(
-                                    format!("split-button-left-{}", commit_label).into(),
-                                ))
-                                .layer(ui::ElevationIndex::ModalSurface)
-                                .size(ui::ButtonSize::Compact)
-                                .child(
-                                    div()
-                                        .child(Label::new(commit_label).size(LabelSize::Small))
-                                        .mr_0p5(),
+                        .on_click(cx.listener(move |this, _: &ClickEvent, window, cx| {
+                            telemetry::event!("Git Committed", source = "Git Modal");
+                            this.git_panel.update(cx, |git_panel, cx| {
+                                git_panel.commit_changes(
+                                    CommitOptions {
+                                        amend: is_amend_pending,
+                                        signoff: is_signoff_enabled,
+                                    },
+                                    window,
+                                    cx,
                                 )
-                                .on_click(cx.listener(move |this, _: &ClickEvent, window, cx| {
-                                    telemetry::event!("Git Committed", source = "Git Modal");
-                                    this.git_panel.update(cx, |git_panel, cx| {
-                                        git_panel.commit_changes(
-                                            CommitOptions { amend: false },
-                                            window,
-                                            cx,
-                                        )
-                                    });
-                                    cx.emit(DismissEvent);
-                                }))
-                                .disabled(!can_commit)
-                                .tooltip({
-                                    let focus_handle = focus_handle.clone();
-                                    move |window, cx| {
-                                        if can_commit {
-                                            Tooltip::with_meta_in(
-                                                tooltip,
-                                                Some(&git::Commit),
-                                                "git commit",
-                                                &focus_handle.clone(),
-                                                window,
-                                                cx,
-                                            )
-                                        } else {
-                                            Tooltip::simple(tooltip, cx)
-                                        }
-                                    }
-                                }),
-                                self.render_git_commit_menu(
-                                    ElementId::Name(
-                                        format!("split-button-right-{}", commit_label).into(),
-                                    ),
-                                    Some(focus_handle.clone()),
-                                )
-                                .into_any_element(),
-                            ))
-                        })
-                        .when(!has_previous_commit, |this| {
-                            this.child(
-                                panel_filled_button(commit_label)
-                                    .tooltip(move |window, cx| {
-                                        if can_commit {
-                                            Tooltip::with_meta_in(
-                                                tooltip,
-                                                Some(&git::Commit),
-                                                "git commit",
-                                                &focus_handle,
-                                                window,
-                                                cx,
-                                            )
-                                        } else {
-                                            Tooltip::simple(tooltip, cx)
-                                        }
-                                    })
-                                    .disabled(!can_commit)
-                                    .on_click(cx.listener(
-                                        move |this, _: &ClickEvent, window, cx| {
-                                            telemetry::event!(
-                                                "Git Committed",
-                                                source = "Git Modal"
-                                            );
-                                            this.git_panel.update(cx, |git_panel, cx| {
-                                                git_panel.commit_changes(
-                                                    CommitOptions { amend: false },
-                                                    window,
-                                                    cx,
-                                                )
-                                            });
-                                            cx.emit(DismissEvent);
-                                        },
-                                    )),
-                            )
-                        })
-                    }),
+                            });
+                            cx.emit(DismissEvent);
+                        }))
+                        .disabled(!can_commit)
+                        .tooltip({
+                            let focus_handle = focus_handle.clone();
+                            move |window, cx| {
+                                if can_commit {
+                                    Tooltip::with_meta_in(
+                                        tooltip,
+                                        Some(&git::Commit),
+                                        format!(
+                                            "git commit{}{}",
+                                            if is_amend_pending { " --amend" } else { "" },
+                                            if is_signoff_enabled { " --signoff" } else { "" }
+                                        ),
+                                        &focus_handle.clone(),
+                                        window,
+                                        cx,
+                                    )
+                                } else {
+                                    Tooltip::simple(tooltip, cx)
+                                }
+                            }
+                        }),
+                        self.render_git_commit_menu(
+                            ElementId::Name(format!("split-button-right-{}", commit_label).into()),
+                            Some(focus_handle.clone()),
+                        )
+                        .into_any_element(),
+                    )),
             )
     }
 
@@ -534,7 +501,14 @@ impl CommitModal {
         }
         telemetry::event!("Git Committed", source = "Git Modal");
         self.git_panel.update(cx, |git_panel, cx| {
-            git_panel.commit_changes(CommitOptions { amend: false }, window, cx)
+            git_panel.commit_changes(
+                CommitOptions {
+                    amend: false,
+                    signoff: git_panel.signoff_enabled(),
+                },
+                window,
+                cx,
+            )
         });
         cx.emit(DismissEvent);
     }
@@ -559,7 +533,14 @@ impl CommitModal {
             telemetry::event!("Git Amended", source = "Git Modal");
             self.git_panel.update(cx, |git_panel, cx| {
                 git_panel.set_amend_pending(false, cx);
-                git_panel.commit_changes(CommitOptions { amend: true }, window, cx);
+                git_panel.commit_changes(
+                    CommitOptions {
+                        amend: true,
+                        signoff: git_panel.signoff_enabled(),
+                    },
+                    window,
+                    cx,
+                );
             });
             cx.emit(DismissEvent);
         }