Merge branch 'debugger' into variable-list-tear-down

Breakpoint store teardown

.github/ISSUE_TEMPLATE/1_bug_report.yml

@@ -10,16 +10,39 @@ body:
       value: |
         <!-- Please insert a one line summary of the issue below -->
 
-        <!-- Include all steps necessary to reproduce from a clean Zed installation. Be verbose -->
+        SUMMARY_SENTENCE_HERE
+
+        <!-- Be verbose: Include all steps necessary to reproduce from a clean Zed installation. -->
+        <!-- Code snippets are better than images, a repository link that reproduces the issue is ideal. -->
+
         Steps to trigger the problem:
         1.
         2.
         3.
+        4.
 
         Actual Behavior:
 
         Expected Behavior:
 
+        <!--
+          Is there anything additional necessary to reproduce this issue?
+            - settings.json, keymap.json, .editorconfig etc?
+            - Does it happen intermittently or only with specific projects / file types?
+            - Have you found a workaround?
+
+          Did you check your Zed.log to see if there is any relevant details there?
+            - When including large items (videos, screenshots, logs, configs) please wrap with:
+
+          <details><summary>See inside for XXXXYYY</summary>
+
+          ```shell
+          code
+          ```
+
+          </details>
+        -->
+
     validations:
       required: true
 

.github/workflows/ci.yml

@@ -109,8 +109,16 @@ jobs:
       - name: cargo clippy
         run: ./script/clippy
 
+      - name: Install cargo-machete
+        uses: clechasseur/rs-cargo@v2
+        with:
+          command: install
+          args: cargo-machete@0.7.0
+
       - name: Check unused dependencies
-        uses: bnjbvr/cargo-machete@main
+        uses: clechasseur/rs-cargo@v2
+        with:
+          command: machete
 
       - name: Check licenses
         run: |
@@ -298,8 +306,9 @@ jobs:
     env:
       MACOS_CERTIFICATE: ${{ secrets.MACOS_CERTIFICATE }}
       MACOS_CERTIFICATE_PASSWORD: ${{ secrets.MACOS_CERTIFICATE_PASSWORD }}
-      APPLE_NOTARIZATION_USERNAME: ${{ secrets.APPLE_NOTARIZATION_USERNAME }}
-      APPLE_NOTARIZATION_PASSWORD: ${{ secrets.APPLE_NOTARIZATION_PASSWORD }}
+      APPLE_NOTARIZATION_KEY: ${{ secrets.APPLE_NOTARIZATION_KEY }}
+      APPLE_NOTARIZATION_KEY_ID: ${{ secrets.APPLE_NOTARIZATION_KEY_ID }}
+      APPLE_NOTARIZATION_ISSUER_ID: ${{ secrets.APPLE_NOTARIZATION_ISSUER_ID }}
       ZED_CLIENT_CHECKSUM_SEED: ${{ secrets.ZED_CLIENT_CHECKSUM_SEED }}
       ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON: ${{ secrets.ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON }}
       DIGITALOCEAN_SPACES_ACCESS_KEY: ${{ secrets.DIGITALOCEAN_SPACES_ACCESS_KEY }}

.github/workflows/release_nightly.yml

@@ -62,8 +62,9 @@ jobs:
     env:
       MACOS_CERTIFICATE: ${{ secrets.MACOS_CERTIFICATE }}
       MACOS_CERTIFICATE_PASSWORD: ${{ secrets.MACOS_CERTIFICATE_PASSWORD }}
-      APPLE_NOTARIZATION_USERNAME: ${{ secrets.APPLE_NOTARIZATION_USERNAME }}
-      APPLE_NOTARIZATION_PASSWORD: ${{ secrets.APPLE_NOTARIZATION_PASSWORD }}
+      APPLE_NOTARIZATION_KEY: ${{ secrets.APPLE_NOTARIZATION_KEY }}
+      APPLE_NOTARIZATION_KEY_ID: ${{ secrets.APPLE_NOTARIZATION_KEY_ID }}
+      APPLE_NOTARIZATION_ISSUER_ID: ${{ secrets.APPLE_NOTARIZATION_ISSUER_ID }}
       DIGITALOCEAN_SPACES_ACCESS_KEY: ${{ secrets.DIGITALOCEAN_SPACES_ACCESS_KEY }}
       DIGITALOCEAN_SPACES_SECRET_KEY: ${{ secrets.DIGITALOCEAN_SPACES_SECRET_KEY }}
       ZED_CLIENT_CHECKSUM_SEED: ${{ secrets.ZED_CLIENT_CHECKSUM_SEED }}

.zed/debug.json

@@ -0,0 +1,19 @@
+[
+  {
+    "label": "Debug Zed with LLDB",
+    "adapter": "lldb",
+    "program": "$ZED_WORKTREE_ROOT/target/debug/zed",
+    "request": "launch",
+    "cwd": "$ZED_WORKTREE_ROOT"
+  },
+  {
+    "label": "Debug Zed with GDB",
+    "adapter": "gdb",
+    "program": "$ZED_WORKTREE_ROOT/target/debug/zed",
+    "request": "launch",
+    "cwd": "$ZED_WORKTREE_ROOT",
+    "initialize_args": {
+      "stopAtBeginningOfMainSubprogram": true
+    }
+  }
+]

Cargo.lock

@@ -13,7 +13,6 @@ dependencies = [
  "futures 0.3.31",
  "gpui",
  "language",
- "lsp",
  "project",
  "smallvec",
  "ui",
@@ -395,7 +394,6 @@ dependencies = [
  "language",
  "language_model",
  "language_model_selector",
- "language_models",
  "languages",
  "log",
  "lsp",
@@ -463,7 +461,6 @@ dependencies = [
  "language",
  "language_model",
  "language_model_selector",
- "language_models",
  "log",
  "lsp",
  "markdown",
@@ -518,7 +515,6 @@ dependencies = [
  "language",
  "language_model",
  "language_model_selector",
- "language_models",
  "languages",
  "log",
  "multi_buffer",
@@ -1269,6 +1265,30 @@ dependencies = [
  "uuid",
 ]
 
+[[package]]
+name = "aws-sdk-bedrockruntime"
+version = "1.74.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6938541d1948a543bca23303fec4cff9c36bf0e63b8fa3ae1b337bcb9d5b81af"
+dependencies = [
+ "aws-credential-types",
+ "aws-runtime",
+ "aws-smithy-async",
+ "aws-smithy-eventstream",
+ "aws-smithy-http",
+ "aws-smithy-json",
+ "aws-smithy-runtime",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "aws-types",
+ "bytes 1.10.0",
+ "fastrand 2.3.0",
+ "http 0.2.12",
+ "once_cell",
+ "regex-lite",
+ "tracing",
+]
+
 [[package]]
 name = "aws-sdk-kinesis"
 version = "1.61.0"
@@ -1598,6 +1618,17 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "aws_http_client"
+version = "0.1.0"
+dependencies = [
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "futures 0.3.31",
+ "http_client",
+ "tokio",
+]
+
 [[package]]
 name = "axum"
 version = "0.6.20"
@@ -1727,6 +1758,22 @@ version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
 
+[[package]]
+name = "bedrock"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "aws-sdk-bedrockruntime",
+ "aws-smithy-types",
+ "futures 0.3.31",
+ "schemars",
+ "serde",
+ "serde_json",
+ "strum",
+ "thiserror 1.0.69",
+ "tokio",
+]
+
 [[package]]
 name = "bigdecimal"
 version = "0.4.7"
@@ -2772,9 +2819,12 @@ dependencies = [
  "clock",
  "collab_ui",
  "collections",
+ "command_palette_hooks",
  "context_server",
  "ctor",
+ "dap",
  "dashmap 6.1.0",
+ "debugger_ui",
  "derive_more",
  "editor",
  "env_logger 0.11.6",
@@ -3112,7 +3162,9 @@ dependencies = [
  "clock",
  "collections",
  "command_palette_hooks",
+ "ctor",
  "editor",
+ "env_logger 0.11.6",
  "fs",
  "futures 0.3.31",
  "gpui",
@@ -3120,6 +3172,7 @@ dependencies = [
  "indoc",
  "inline_completion",
  "language",
+ "log",
  "lsp",
  "menu",
  "node_runtime",
@@ -3699,6 +3752,67 @@ dependencies = [
  "syn 2.0.90",
 ]
 
+[[package]]
+name = "dap"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "async-compression",
+ "async-pipe",
+ "async-tar",
+ "async-trait",
+ "client",
+ "collections",
+ "dap-types",
+ "env_logger 0.11.6",
+ "fs",
+ "futures 0.3.31",
+ "gpui",
+ "http_client",
+ "language",
+ "log",
+ "node_runtime",
+ "parking_lot",
+ "paths",
+ "schemars",
+ "serde",
+ "serde_json",
+ "settings",
+ "smallvec",
+ "smol",
+ "sysinfo",
+ "task",
+ "util",
+]
+
+[[package]]
+name = "dap-types"
+version = "0.0.1"
+source = "git+https://github.com/zed-industries/dap-types?rev=bf5632dc19f806e8a435c9f04a4bfe7322badea2#bf5632dc19f806e8a435c9f04a4bfe7322badea2"
+dependencies = [
+ "schemars",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "dap_adapters"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "async-trait",
+ "dap",
+ "gpui",
+ "language",
+ "paths",
+ "regex",
+ "serde",
+ "serde_json",
+ "sysinfo",
+ "task",
+ "util",
+]
+
 [[package]]
 name = "dashmap"
 version = "5.5.3"
@@ -3772,6 +3886,59 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "debugger_tools"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "dap",
+ "editor",
+ "futures 0.3.31",
+ "gpui",
+ "project",
+ "serde_json",
+ "settings",
+ "smol",
+ "util",
+ "workspace",
+]
+
+[[package]]
+name = "debugger_ui"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "client",
+ "collections",
+ "command_palette_hooks",
+ "dap",
+ "editor",
+ "env_logger 0.11.6",
+ "feature_flags",
+ "fuzzy",
+ "gpui",
+ "language",
+ "log",
+ "menu",
+ "picker",
+ "pretty_assertions",
+ "project",
+ "rpc",
+ "serde",
+ "serde_json",
+ "settings",
+ "sum_tree",
+ "sysinfo",
+ "task",
+ "tasks_ui",
+ "terminal_view",
+ "theme",
+ "ui",
+ "unindent",
+ "util",
+ "workspace",
+]
+
 [[package]]
 name = "deepseek"
 version = "0.1.0"
@@ -4072,6 +4239,7 @@ dependencies = [
  "log",
  "lsp",
  "markdown",
+ "menu",
  "multi_buffer",
  "ordered-float 2.10.1",
  "parking_lot",
@@ -5295,6 +5463,7 @@ dependencies = [
  "pretty_assertions",
  "regex",
  "rope",
+ "schemars",
  "serde",
  "serde_json",
  "smol",
@@ -6959,17 +7128,14 @@ dependencies = [
  "anthropic",
  "anyhow",
  "base64 0.22.1",
+ "client",
  "collections",
- "deepseek",
  "futures 0.3.31",
  "google_ai",
  "gpui",
  "http_client",
  "image",
- "lmstudio",
  "log",
- "mistral",
- "ollama",
  "open_ai",
  "parking_lot",
  "proto",
@@ -6978,6 +7144,7 @@ dependencies = [
  "serde_json",
  "smol",
  "strum",
+ "telemetry_events",
  "thiserror 1.0.69",
  "ui",
  "util",
@@ -7004,6 +7171,10 @@ version = "0.1.0"
 dependencies = [
  "anthropic",
  "anyhow",
+ "aws-config",
+ "aws-credential-types",
+ "aws_http_client",
+ "bedrock",
  "client",
  "collections",
  "copilot",
@@ -7015,6 +7186,7 @@ dependencies = [
  "futures 0.3.31",
  "google_ai",
  "gpui",
+ "gpui_tokio",
  "http_client",
  "language_model",
  "lmstudio",
@@ -7030,10 +7202,9 @@ dependencies = [
  "settings",
  "smol",
  "strum",
- "telemetry_events",
  "theme",
- "thiserror 1.0.69",
  "tiktoken-rs",
+ "tokio",
  "ui",
  "util",
 ]
@@ -10124,6 +10295,8 @@ dependencies = [
  "client",
  "clock",
  "collections",
+ "dap",
+ "dap_adapters",
  "env_logger 0.11.6",
  "fancy-regex 0.14.0",
  "fs",
@@ -10135,6 +10308,7 @@ dependencies = [
  "gpui",
  "http_client",
  "image",
+ "indexmap",
  "itertools 0.14.0",
  "language",
  "log",
@@ -10783,6 +10957,7 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "auto_update",
+ "dap",
  "editor",
  "extension_host",
  "file_finder",
@@ -13302,6 +13477,7 @@ dependencies = [
  "parking_lot",
  "schemars",
  "serde",
+ "serde_json",
  "serde_json_lenient",
  "sha2",
  "shellexpand 2.1.2",
@@ -16706,6 +16882,8 @@ dependencies = [
  "component_preview",
  "copilot",
  "db",
+ "debugger_tools",
+ "debugger_ui",
  "diagnostics",
  "editor",
  "env_logger 0.11.6",
@@ -17139,7 +17317,7 @@ dependencies = [
  "indoc",
  "inline_completion",
  "language",
- "language_models",
+ "language_model",
  "log",
  "menu",
  "migrator",

Cargo.toml

@@ -15,6 +15,8 @@ members = [
     "crates/audio",
     "crates/auto_update",
     "crates/auto_update_ui",
+    "crates/aws_http_client",
+    "crates/bedrock",
     "crates/breadcrumbs",
     "crates/buffer_diff",
     "crates/call",
@@ -33,6 +35,10 @@ members = [
     "crates/context_server_settings",
     "crates/copilot",
     "crates/credentials_provider",
+    "crates/dap",
+    "crates/dap_adapters",
+    "crates/debugger_tools",
+    "crates/debugger_ui",
     "crates/db",
     "crates/deepseek",
     "crates/diagnostics",
@@ -218,6 +224,8 @@ assistant_tools = { path = "crates/assistant_tools" }
 audio = { path = "crates/audio" }
 auto_update = { path = "crates/auto_update" }
 auto_update_ui = { path = "crates/auto_update_ui" }
+aws_http_client = { path = "crates/aws_http_client" }
+bedrock = { path = "crates/bedrock" }
 breadcrumbs = { path = "crates/breadcrumbs" }
 call = { path = "crates/call" }
 channel = { path = "crates/channel" }
@@ -235,7 +243,11 @@ context_server = { path = "crates/context_server" }
 context_server_settings = { path = "crates/context_server_settings" }
 copilot = { path = "crates/copilot" }
 credentials_provider = { path = "crates/credentials_provider" }
+dap = { path = "crates/dap" }
+dap_adapters = { path = "crates/dap_adapters" }
 db = { path = "crates/db" }
+debugger_ui = { path = "crates/debugger_ui" }
+debugger_tools = { path = "crates/debugger_tools" }
 deepseek = { path = "crates/deepseek" }
 diagnostics = { path = "crates/diagnostics" }
 buffer_diff = { path = "crates/buffer_diff" }
@@ -382,6 +394,11 @@ async-trait = "0.1"
 async-tungstenite = "0.28"
 async-watch = "0.3.1"
 async_zip = { version = "0.0.17", features = ["deflate", "deflate64"] }
+aws-config = { version = "1.5.16", features = ["behavior-version-latest"] }
+aws-credential-types = { version = "1.2.1", features = ["hardcoded-credentials"] }
+aws-sdk-bedrockruntime = { version = "1.73.0", features = ["behavior-version-latest"] }
+aws-smithy-runtime-api = { version = "1.7.3", features = ["http-1x", "client"] }
+aws-smithy-types = { version = "1.2.13", features = ["http-body-1-x"] }
 base64 = "0.22"
 bitflags = "2.6.0"
 blade-graphics = { git = "https://github.com/kvark/blade", rev = "b16f5c7bd873c7126f48c82c39e7ae64602ae74f" }

assets/icons/ai_bedrock.svg

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="283.6413 127.3453 56 55.9999" width="16px" height="16px">
+  <path d="M 808.592 158.131 C 807.489 158.131 806.592 157.234 806.592 156.131 C 806.592 155.028 807.489 154.131 808.592 154.131 C 809.695 154.131 810.592 155.028 810.592 156.131 C 810.592 157.234 809.695 158.131 808.592 158.131 Z M 776.705 185.039 L 773.457 183.145 L 780.122 178.979 L 779.062 177.283 L 771.505 182.006 L 765.592 178.557 L 765.592 169.666 L 771.147 165.963 L 770.037 164.299 L 764.551 167.956 L 758.592 164.551 L 758.592 159.711 L 765.088 155.999 L 764.096 154.263 L 758.592 157.408 L 758.592 153.711 L 764.592 150.283 L 770.592 153.711 L 770.592 157.565 L 766.077 160.274 L 767.107 161.988 L 771.592 159.297 L 776.077 161.988 L 777.107 160.274 L 772.592 157.565 L 772.592 153.666 L 778.147 149.963 C 778.425 149.777 778.592 149.465 778.592 149.131 L 778.592 142.131 L 776.592 142.131 L 776.592 148.596 L 771.551 151.956 L 765.592 148.551 L 765.592 139.705 L 770.592 136.789 L 770.592 145.131 L 772.592 145.131 L 772.592 135.622 L 776.705 133.223 L 784.592 135.852 L 784.592 164.565 L 770.077 173.274 L 771.107 174.988 L 784.592 166.897 L 784.592 182.41 L 776.705 185.039 Z M 806.592 169.131 C 806.592 170.234 805.695 171.131 804.592 171.131 C 803.489 171.131 802.592 170.234 802.592 169.131 C 802.592 168.028 803.489 167.131 804.592 167.131 C 805.695 167.131 806.592 168.028 806.592 169.131 Z M 796.592 179.131 C 796.592 180.234 795.695 181.131 794.592 181.131 C 793.489 181.131 792.592 180.234 792.592 179.131 C 792.592 178.028 793.489 177.131 794.592 177.131 C 795.695 177.131 796.592 178.028 796.592 179.131 Z M 795.592 139.131 C 795.592 138.028 796.489 137.131 797.592 137.131 C 798.695 137.131 799.592 138.028 799.592 139.131 C 799.592 140.234 798.695 141.131 797.592 141.131 C 796.489 141.131 795.592 140.234 795.592 139.131 Z M 808.592 152.131 C 806.733 152.131 805.181 153.411 804.734 155.131 L 786.592 155.131 L 786.592 150.131 L 797.592 150.131 C 798.145 150.131 798.592 149.683 798.592 149.131 L 798.592 142.989 C 800.312 142.542 801.592 140.989 801.592 139.131 C 801.592 136.925 799.798 135.131 797.592 135.131 C 795.386 135.131 793.592 136.925 793.592 139.131 C 793.592 140.989 794.872 142.542 796.592 142.989 L 796.592 148.131 L 786.592 148.131 L 786.592 135.131 C 786.592 134.7 786.317 134.319 785.908 134.182 L 776.908 131.182 C 776.634 131.092 776.336 131.122 776.088 131.267 L 764.088 138.267 C 763.78 138.446 763.592 138.776 763.592 139.131 L 763.592 148.551 L 757.096 152.263 C 756.784 152.441 756.592 152.772 756.592 153.131 L 756.592 165.131 C 756.592 165.49 756.784 165.821 757.096 165.999 L 763.592 169.711 L 763.592 179.131 C 763.592 179.486 763.78 179.816 764.088 179.995 L 776.088 186.995 C 776.242 187.085 776.417 187.131 776.592 187.131 C 776.698 187.131 776.805 187.114 776.908 187.08 L 785.908 184.08 C 786.317 183.943 786.592 183.562 786.592 183.131 L 786.592 171.131 L 793.592 171.131 L 793.592 175.273 C 791.872 175.72 790.592 177.273 790.592 179.131 C 790.592 181.337 792.386 183.131 794.592 183.131 C 796.798 183.131 798.592 181.337 798.592 179.131 C 798.592 177.273 797.312 175.72 795.592 175.273 L 795.592 170.131 C 795.592 169.579 795.145 169.131 794.592 169.131 L 786.592 169.131 L 786.592 164.131 L 799.092 164.131 L 801.23 166.981 C 800.831 167.603 800.592 168.338 800.592 169.131 C 800.592 171.337 802.386 173.131 804.592 173.131 C 806.798 173.131 808.592 171.337 808.592 169.131 C 808.592 166.925 806.798 165.131 804.592 165.131 C 803.908 165.131 803.274 165.319 802.711 165.623 L 800.392 162.531 C 800.203 162.279 799.906 162.131 799.592 162.131 L 786.592 162.131 L 786.592 157.131 L 804.734 157.131 C 805.181 158.851 806.733 160.131 808.592 160.131 C 810.798 160.131 812.592 158.337 812.592 156.131 C 812.592 153.925 810.798 152.131 808.592 152.131 Z" fill-rule="evenodd" fill-opacity="1" style="" id="object-0" transform="matrix(1, 0, 0, 1, -472.9506530761719, -3.7858259677886963)"/>
+</svg>

assets/icons/debug.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-bug"><path d="m8 2 1.88 1.88"/><path d="M14.12 3.88 16 2"/><path d="M9 7.13v-1a3.003 3.003 0 1 1 6 0v1"/><path d="M12 20c-3.3 0-6-2.7-6-6v-3a4 4 0 0 1 4-4h4a4 4 0 0 1 4 4v3c0 3.3-2.7 6-6 6"/><path d="M12 20v-9"/><path d="M6.53 9C4.6 8.8 3 7.1 3 5"/><path d="M6 13H2"/><path d="M3 21c0-2.1 1.7-3.9 3.8-4"/><path d="M20.97 5c0 2.1-1.6 3.8-3.5 4"/><path d="M22 13h-4"/><path d="M17.2 17c2.1.1 3.8 1.9 3.8 4"/></svg>

assets/icons/debug_breakpoint.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="currentColor" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-circle"><circle cx="12" cy="12" r="10"/></svg>

assets/icons/debug_continue.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-step-forward"><line x1="6" x2="6" y1="4" y2="20"/><polygon points="10,4 20,12 10,20"/></svg>

assets/icons/debug_disconnect.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-unplug"><path d="m19 5 3-3"/><path d="m2 22 3-3"/><path d="M6.3 20.3a2.4 2.4 0 0 0 3.4 0L12 18l-6-6-2.3 2.3a2.4 2.4 0 0 0 0 3.4Z"/><path d="M7.5 13.5 10 11"/><path d="M10.5 16.5 13 14"/><path d="m12 6 6 6 2.3-2.3a2.4 2.4 0 0 0 0-3.4l-2.6-2.6a2.4 2.4 0 0 0-3.4 0Z"/></svg>

assets/icons/debug_ignore_breakpoints.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-circle-off"><path d="m2 2 20 20"/><path d="M8.35 2.69A10 10 0 0 1 21.3 15.65"/><path d="M19.08 19.08A10 10 0 1 1 4.92 4.92"/></svg>

assets/icons/debug_log_breakpoint.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="currentColor" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-message-circle"><path d="M7.9 20A9 9 0 1 0 4 16.1L2 22Z"/></svg>

assets/icons/debug_pause.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-pause"><rect x="14" y="4" width="4" height="16" rx="1"/><rect x="6" y="4" width="4" height="16" rx="1"/></svg>

assets/icons/debug_restart.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-rotate-ccw"><path d="M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8"/><path d="M3 3v5h5"/></svg>

assets/icons/debug_step_back.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-undo-dot"><path d="M21 17a9 9 0 0 0-15-6.7L3 13"/><path d="M3 7v6h6"/><circle cx="12" cy="17" r="1"/></svg>

assets/icons/debug_step_into.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-arrow-up-from-dot">
+  <path d="m5 15 7 7 7-7"/>
+  <path d="M12 8v14"/>
+  <circle cx="12" cy="3" r="1"/>
+</svg>

assets/icons/debug_step_out.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-arrow-up-from-dot">
+  <path d="m3 10 9-8 9 8"/>
+  <path d="M12 17V2"/>
+  <circle cx="12" cy="21" r="1"/>
+</svg>

assets/icons/debug_step_over.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-redo-dot">
+  <circle cx="12" cy="17" r="1"/>
+  <path d="M21 7v6h-6"/>
+  <path d="M3 17a9 9 0 0 1 9-9 9 9 0 0 1 6 2.3l3 2.7"/>
+</svg>

assets/icons/debug_stop.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-square"><rect width="18" height="18" x="3" y="3" rx="2"/></svg>

assets/keymaps/default-linux.json

@@ -184,9 +184,9 @@
       "ctrl-alt-/": "assistant::ToggleModelSelector",
       "ctrl-k h": "assistant::DeployHistory",
       "ctrl-k l": "assistant::DeployPromptLibrary",
-      "new": "assistant::NewContext",
-      "ctrl-t": "assistant::NewContext",
-      "ctrl-n": "assistant::NewContext"
+      "new": "assistant::NewChat",
+      "ctrl-t": "assistant::NewChat",
+      "ctrl-n": "assistant::NewChat"
     }
   },
   {
@@ -368,7 +368,12 @@
       "ctrl-\\": "pane::SplitRight",
       "ctrl-k v": "markdown::OpenPreviewToTheSide",
       "ctrl-shift-v": "markdown::OpenPreview",
-      "ctrl-alt-shift-c": "editor::DisplayCursorNames"
+      "ctrl-alt-shift-c": "editor::DisplayCursorNames",
+      "ctrl-alt-y": "git::ToggleStaged",
+      "alt-y": "git::StageAndNext",
+      "alt-shift-y": "git::UnstageAndNext",
+      "alt-.": "editor::GoToHunk",
+      "alt-,": "editor::GoToPrevHunk"
     }
   },
   {
@@ -705,12 +710,6 @@
       "space": "project_panel::Open"
     }
   },
-  {
-    "context": "GitPanel && !CommitEditor",
-    "bindings": {
-      "escape": "git_panel::Close"
-    }
-  },
   {
     "context": "GitPanel && ChangesList",
     "bindings": {
@@ -722,19 +721,36 @@
       "ctrl-shift-space": "git::UnstageAll",
       "tab": "git_panel::FocusEditor",
       "shift-tab": "git_panel::FocusEditor",
-      "escape": "git_panel::ToggleFocus"
+      "escape": "git_panel::ToggleFocus",
+      "ctrl-enter": "git::Commit",
+      "alt-enter": "menu::SecondaryConfirm"
+    }
+  },
+  {
+    "context": "GitCommit > Editor",
+    "bindings": {
+      "enter": "editor::Newline",
+      "ctrl-enter": "git::Commit"
     }
   },
   {
     "context": "GitPanel > Editor",
     "bindings": {
       "escape": "git_panel::FocusChanges",
-      "ctrl-enter": "git::Commit",
       "tab": "git_panel::FocusChanges",
       "shift-tab": "git_panel::FocusChanges",
+      "ctrl-enter": "git::Commit",
       "alt-up": "git_panel::FocusChanges"
     }
   },
+  {
+    "context": "GitCommit > Editor",
+    "use_key_equivalents": true,
+    "bindings": {
+      "enter": "editor::Newline",
+      "ctrl-enter": "git::Commit"
+    }
+  },
   {
     "context": "CollabPanel && not_editing",
     "bindings": {
@@ -813,6 +829,7 @@
       "pagedown": ["terminal::SendKeystroke", "pagedown"],
       "escape": ["terminal::SendKeystroke", "escape"],
       "enter": ["terminal::SendKeystroke", "enter"],
+      "ctrl-b": ["terminal::SendKeystroke", "ctrl-b"],
       "ctrl-c": ["terminal::SendKeystroke", "ctrl-c"],
       "shift-pageup": "terminal::ScrollPageUp",
       "shift-pagedown": "terminal::ScrollPageDown",

assets/keymaps/default-macos.json

@@ -211,8 +211,8 @@
       "cmd-alt-/": "assistant::ToggleModelSelector",
       "cmd-k h": "assistant::DeployHistory",
       "cmd-k l": "assistant::DeployPromptLibrary",
-      "cmd-t": "assistant::NewContext",
-      "cmd-n": "assistant::NewContext"
+      "cmd-t": "assistant::NewChat",
+      "cmd-n": "assistant::NewChat"
     }
   },
   {
@@ -724,6 +724,14 @@
       "space": "project_panel::Open"
     }
   },
+  {
+    "context": "VariableList",
+    "use_key_equivalents": true,
+    "bindings": {
+      "left": "variable_list::CollapseSelectedEntry",
+      "right": "variable_list::ExpandSelectedEntry"
+    }
+  },
   {
     "context": "GitPanel && ChangesList",
     "use_key_equivalents": true,
@@ -742,14 +750,6 @@
       "escape": "git_panel::ToggleFocus"
     }
   },
-  {
-    "context": "GitCommit > Editor",
-    "use_key_equivalents": true,
-    "bindings": {
-      "enter": "editor::Newline",
-      "cmd-enter": "git::Commit"
-    }
-  },
   {
     "context": "GitPanel > Editor",
     "use_key_equivalents": true,
@@ -761,6 +761,14 @@
       "alt-up": "git_panel::FocusChanges"
     }
   },
+  {
+    "context": "GitCommit > Editor",
+    "use_key_equivalents": true,
+    "bindings": {
+      "enter": "editor::Newline",
+      "cmd-enter": "git::Commit"
+    }
+  },
   {
     "context": "CollabPanel && not_editing",
     "use_key_equivalents": true,

assets/keymaps/linux/emacs.json

@@ -48,6 +48,8 @@
       "ctrl-_": "editor::Undo", // undo
       "ctrl-/": "editor::Undo", // undo
       "ctrl-x u": "editor::Undo", // undo
+      "alt-{": "editor::MoveToStartOfParagraph", // backward-paragraph
+      "alt-}": "editor::MoveToEndOfParagraph", // forward-paragraph
       "ctrl-v": "editor::MovePageDown", // scroll-up
       "alt-v": "editor::MovePageUp", // scroll-down
       "ctrl-x [": "editor::MoveToBeginning", // beginning-of-buffer

assets/keymaps/macos/emacs.json

@@ -48,6 +48,8 @@
       "ctrl-_": "editor::Undo", // undo
       "ctrl-/": "editor::Undo", // undo
       "ctrl-x u": "editor::Undo", // undo
+      "alt-{": "editor::MoveToStartOfParagraph", // backward-paragraph
+      "alt-}": "editor::MoveToEndOfParagraph", // forward-paragraph
       "ctrl-v": "editor::MovePageDown", // scroll-up
       "alt-v": "editor::MovePageUp", // scroll-down
       "ctrl-x [": "editor::MoveToBeginning", // beginning-of-buffer

assets/settings/default.json

@@ -581,7 +581,7 @@
       // The provider to use.
       "provider": "zed.dev",
       // The model to use.
-      "model": "claude-3-5-sonnet"
+      "model": "claude-3-5-sonnet-latest"
     }
   },
   // The settings for slash commands.
@@ -1093,6 +1093,7 @@
       "tab_size": 2
     },
     "Diff": {
+      "show_edit_predictions": false,
       "remove_trailing_whitespace_on_save": false,
       "ensure_final_newline_on_save": false
     },
@@ -1375,6 +1376,12 @@
   //   }
   // ]
   "ssh_connections": [],
+
   // Configures context servers for use in the Assistant.
-  "context_servers": {}
+  "context_servers": {},
+  "debugger": {
+    "stepping_granularity": "line",
+    "save_breakpoints": true,
+    "button": true
+  }
 }

assets/settings/initial_debug_tasks.json

@@ -0,0 +1,32 @@
+[
+  {
+    "label": "Debug active PHP file",
+    "adapter": "php",
+    "program": "$ZED_FILE",
+    "request": "launch",
+    "cwd": "$ZED_WORKTREE_ROOT"
+  },
+  {
+    "label": "Debug active Python file",
+    "adapter": "python",
+    "program": "$ZED_FILE",
+    "request": "launch",
+    "cwd": "$ZED_WORKTREE_ROOT"
+  },
+  {
+    "label": "Debug active JavaScript file",
+    "adapter": "javascript",
+    "program": "$ZED_FILE",
+    "request": "launch",
+    "cwd": "$ZED_WORKTREE_ROOT"
+  },
+  {
+    "label": "JavaScript debug terminal",
+    "adapter": "javascript",
+    "request": "launch",
+    "cwd": "$ZED_WORKTREE_ROOT",
+    "initialize_args": {
+      "console": "integratedTerminal"
+    }
+  }
+]

assets/themes/gruvbox/gruvbox.json

@@ -379,7 +379,7 @@
             "font_weight": null
           },
           "variable": {
-            "color": "#83a598ff",
+            "color": "#ebdbb2ff",
             "font_style": null,
             "font_weight": null
           },
@@ -767,7 +767,7 @@
             "font_weight": null
           },
           "variable": {
-            "color": "#83a598ff",
+            "color": "#ebdbb2ff",
             "font_style": null,
             "font_weight": null
           },
@@ -1155,7 +1155,7 @@
             "font_weight": null
           },
           "variable": {
-            "color": "#83a598ff",
+            "color": "#ebdbb2ff",
             "font_style": null,
             "font_weight": null
           },
@@ -1543,7 +1543,7 @@
             "font_weight": null
           },
           "variable": {
-            "color": "#066578ff",
+            "color": "#282828ff",
             "font_style": null,
             "font_weight": null
           },
@@ -1931,7 +1931,7 @@
             "font_weight": null
           },
           "variable": {
-            "color": "#066578ff",
+            "color": "#282828ff",
             "font_style": null,
             "font_weight": null
           },
@@ -2319,7 +2319,7 @@
             "font_weight": null
           },
           "variable": {
-            "color": "#066578ff",
+            "color": "#282828ff",
             "font_style": null,
             "font_weight": null
           },

assets/themes/one/one.json

@@ -365,7 +365,7 @@
             "font_weight": null
           },
           "variable": {
-            "color": "#dce0e5ff",
+            "color": "#acb2beff",
             "font_style": null,
             "font_weight": null
           },

crates/activity_indicator/Cargo.toml

@@ -20,7 +20,6 @@ extension_host.workspace = true
 futures.workspace = true
 gpui.workspace = true
 language.workspace = true
-lsp.workspace = true
 project.workspace = true
 smallvec.workspace = true
 ui.workspace = true

crates/activity_indicator/src/activity_indicator.rs

@@ -7,8 +7,7 @@ use gpui::{
     EventEmitter, InteractiveElement as _, ParentElement as _, Render, SharedString,
     StatefulInteractiveElement, Styled, Transformation, Window,
 };
-use language::{LanguageRegistry, LanguageServerBinaryStatus, LanguageServerId};
-use lsp::LanguageServerName;
+use language::{BinaryStatus, LanguageRegistry, LanguageServerId};
 use project::{EnvironmentErrorMessage, LanguageServerProgress, Project, WorktreeId};
 use smallvec::SmallVec;
 use std::{cmp::Reverse, fmt::Write, sync::Arc, time::Duration};
@@ -20,21 +19,21 @@ actions!(activity_indicator, [ShowErrorMessage]);
 
 pub enum Event {
     ShowError {
-        lsp_name: LanguageServerName,
+        server_name: SharedString,
         error: String,
     },
 }
 
 pub struct ActivityIndicator {
-    statuses: Vec<LspStatus>,
+    statuses: Vec<ServerStatus>,
     project: Entity<Project>,
     auto_updater: Option<Entity<AutoUpdater>>,
     context_menu_handle: PopoverMenuHandle<ContextMenu>,
 }
 
-struct LspStatus {
-    name: LanguageServerName,
-    status: LanguageServerBinaryStatus,
+struct ServerStatus {
+    name: SharedString,
+    status: BinaryStatus,
 }
 
 struct PendingWork<'a> {
@@ -65,7 +64,20 @@ impl ActivityIndicator {
                 while let Some((name, status)) = status_events.next().await {
                     this.update(&mut cx, |this: &mut ActivityIndicator, cx| {
                         this.statuses.retain(|s| s.name != name);
-                        this.statuses.push(LspStatus { name, status });
+                        this.statuses.push(ServerStatus { name, status });
+                        cx.notify();
+                    })?;
+                }
+                anyhow::Ok(())
+            })
+            .detach();
+
+            let mut status_events = languages.dap_server_binary_statuses();
+            cx.spawn(|this, mut cx| async move {
+                while let Some((name, status)) = status_events.next().await {
+                    this.update(&mut cx, |this, cx| {
+                        this.statuses.retain(|s| s.name != name);
+                        this.statuses.push(ServerStatus { name, status });
                         cx.notify();
                     })?;
                 }
@@ -88,18 +100,18 @@ impl ActivityIndicator {
         });
 
         cx.subscribe_in(&this, window, move |_, _, event, window, cx| match event {
-            Event::ShowError { lsp_name, error } => {
+            Event::ShowError { server_name, error } => {
                 let create_buffer = project.update(cx, |project, cx| project.create_buffer(cx));
                 let project = project.clone();
                 let error = error.clone();
-                let lsp_name = lsp_name.clone();
+                let server_name = server_name.clone();
                 cx.spawn_in(window, |workspace, mut cx| async move {
                     let buffer = create_buffer.await?;
                     buffer.update(&mut cx, |buffer, cx| {
                         buffer.edit(
                             [(
                                 0..0,
-                                format!("Language server error: {}\n\n{}", lsp_name, error),
+                                format!("Language server error: {}\n\n{}", server_name, error),
                             )],
                             None,
                             cx,
@@ -129,9 +141,9 @@ impl ActivityIndicator {
 
     fn show_error_message(&mut self, _: &ShowErrorMessage, _: &mut Window, cx: &mut Context<Self>) {
         self.statuses.retain(|status| {
-            if let LanguageServerBinaryStatus::Failed { error } = &status.status {
+            if let BinaryStatus::Failed { error } = &status.status {
                 cx.emit(Event::ShowError {
-                    lsp_name: status.name.clone(),
+                    server_name: status.name.clone(),
                     error: error.clone(),
                 });
                 false
@@ -260,12 +272,10 @@ impl ActivityIndicator {
         let mut failed = SmallVec::<[_; 3]>::new();
         for status in &self.statuses {
             match status.status {
-                LanguageServerBinaryStatus::CheckingForUpdate => {
-                    checking_for_update.push(status.name.clone())
-                }
-                LanguageServerBinaryStatus::Downloading => downloading.push(status.name.clone()),
-                LanguageServerBinaryStatus::Failed { .. } => failed.push(status.name.clone()),
-                LanguageServerBinaryStatus::None => {}
+                BinaryStatus::CheckingForUpdate => checking_for_update.push(status.name.clone()),
+                BinaryStatus::Downloading => downloading.push(status.name.clone()),
+                BinaryStatus::Failed { .. } => failed.push(status.name.clone()),
+                BinaryStatus::None => {}
             }
         }
 
@@ -278,7 +288,7 @@ impl ActivityIndicator {
                 ),
                 message: format!(
                     "Downloading {}...",
-                    downloading.iter().map(|name| name.0.as_ref()).fold(
+                    downloading.iter().map(|name| name.as_ref()).fold(
                         String::new(),
                         |mut acc, s| {
                             if !acc.is_empty() {
@@ -306,7 +316,7 @@ impl ActivityIndicator {
                 ),
                 message: format!(
                     "Checking for updates to {}...",
-                    checking_for_update.iter().map(|name| name.0.as_ref()).fold(
+                    checking_for_update.iter().map(|name| name.as_ref()).fold(
                         String::new(),
                         |mut acc, s| {
                             if !acc.is_empty() {
@@ -336,7 +346,7 @@ impl ActivityIndicator {
                     "Failed to run {}. Click to show error.",
                     failed
                         .iter()
-                        .map(|name| name.0.as_ref())
+                        .map(|name| name.as_ref())
                         .fold(String::new(), |mut acc, s| {
                             if !acc.is_empty() {
                                 acc.push_str(", ");

crates/anthropic/src/anthropic.rs

@@ -30,6 +30,8 @@ pub enum Model {
     #[default]
     #[serde(rename = "claude-3-5-sonnet", alias = "claude-3-5-sonnet-latest")]
     Claude3_5Sonnet,
+    #[serde(rename = "claude-3-7-sonnet", alias = "claude-3-7-sonnet-latest")]
+    Claude3_7Sonnet,
     #[serde(rename = "claude-3-5-haiku", alias = "claude-3-5-haiku-latest")]
     Claude3_5Haiku,
     #[serde(rename = "claude-3-opus", alias = "claude-3-opus-latest")]
@@ -59,6 +61,8 @@ impl Model {
     pub fn from_id(id: &str) -> Result<Self> {
         if id.starts_with("claude-3-5-sonnet") {
             Ok(Self::Claude3_5Sonnet)
+        } else if id.starts_with("claude-3-7-sonnet") {
+            Ok(Self::Claude3_7Sonnet)
         } else if id.starts_with("claude-3-5-haiku") {
             Ok(Self::Claude3_5Haiku)
         } else if id.starts_with("claude-3-opus") {
@@ -75,6 +79,7 @@ impl Model {
     pub fn id(&self) -> &str {
         match self {
             Model::Claude3_5Sonnet => "claude-3-5-sonnet-latest",
+            Model::Claude3_7Sonnet => "claude-3-7-sonnet-latest",
             Model::Claude3_5Haiku => "claude-3-5-haiku-latest",
             Model::Claude3Opus => "claude-3-opus-latest",
             Model::Claude3Sonnet => "claude-3-sonnet-20240229",
@@ -85,6 +90,7 @@ impl Model {
 
     pub fn display_name(&self) -> &str {
         match self {
+            Self::Claude3_7Sonnet => "Claude 3.7 Sonnet",
             Self::Claude3_5Sonnet => "Claude 3.5 Sonnet",
             Self::Claude3_5Haiku => "Claude 3.5 Haiku",
             Self::Claude3Opus => "Claude 3 Opus",
@@ -98,13 +104,14 @@ impl Model {
 
     pub fn cache_configuration(&self) -> Option<AnthropicModelCacheConfiguration> {
         match self {
-            Self::Claude3_5Sonnet | Self::Claude3_5Haiku | Self::Claude3Haiku => {
-                Some(AnthropicModelCacheConfiguration {
-                    min_total_token: 2_048,
-                    should_speculate: true,
-                    max_cache_anchors: 4,
-                })
-            }
+            Self::Claude3_5Sonnet
+            | Self::Claude3_5Haiku
+            | Self::Claude3_7Sonnet
+            | Self::Claude3Haiku => Some(AnthropicModelCacheConfiguration {
+                min_total_token: 2_048,
+                should_speculate: true,
+                max_cache_anchors: 4,
+            }),
             Self::Custom {
                 cache_configuration,
                 ..
@@ -117,6 +124,7 @@ impl Model {
         match self {
             Self::Claude3_5Sonnet
             | Self::Claude3_5Haiku
+            | Self::Claude3_7Sonnet
             | Self::Claude3Opus
             | Self::Claude3Sonnet
             | Self::Claude3Haiku => 200_000,
@@ -127,7 +135,7 @@ impl Model {
     pub fn max_output_tokens(&self) -> u32 {
         match self {
             Self::Claude3Opus | Self::Claude3Sonnet | Self::Claude3Haiku => 4_096,
-            Self::Claude3_5Sonnet | Self::Claude3_5Haiku => 8_192,
+            Self::Claude3_5Sonnet | Self::Claude3_7Sonnet | Self::Claude3_5Haiku => 8_192,
             Self::Custom {
                 max_output_tokens, ..
             } => max_output_tokens.unwrap_or(4_096),
@@ -137,6 +145,7 @@ impl Model {
     pub fn default_temperature(&self) -> f32 {
         match self {
             Self::Claude3_5Sonnet
+            | Self::Claude3_7Sonnet
             | Self::Claude3_5Haiku
             | Self::Claude3Opus
             | Self::Claude3Sonnet

crates/assistant/Cargo.toml

@@ -43,7 +43,6 @@ indoc.workspace = true
 language.workspace = true
 language_model.workspace = true
 language_model_selector.workspace = true
-language_models.workspace = true
 log.workspace = true
 lsp.workspace = true
 menu.workspace = true

crates/assistant/src/assistant.rs

@@ -33,7 +33,7 @@ actions!(
     [
         InsertActivePrompt,
         DeployHistory,
-        NewContext,
+        NewChat,
         CycleNextInlineAssist,
         CyclePreviousInlineAssist
     ]

crates/assistant/src/assistant_panel.rs

@@ -1,6 +1,6 @@
 use crate::assistant_configuration::{ConfigurationView, ConfigurationViewEvent};
 use crate::{
-    terminal_inline_assistant::TerminalInlineAssistant, DeployHistory, InlineAssistant, NewContext,
+    terminal_inline_assistant::TerminalInlineAssistant, DeployHistory, InlineAssistant, NewChat,
 };
 use anyhow::{anyhow, Result};
 use assistant_context_editor::{
@@ -129,7 +129,7 @@ impl AssistantPanel {
                 workspace.project().clone(),
                 Default::default(),
                 None,
-                NewContext.boxed_clone(),
+                NewChat.boxed_clone(),
                 window,
                 cx,
             );
@@ -228,12 +228,12 @@ impl AssistantPanel {
                         IconButton::new("new-chat", IconName::Plus)
                             .icon_size(IconSize::Small)
                             .on_click(cx.listener(|_, _, window, cx| {
-                                window.dispatch_action(NewContext.boxed_clone(), cx)
+                                window.dispatch_action(NewChat.boxed_clone(), cx)
                             }))
                             .tooltip(move |window, cx| {
                                 Tooltip::for_action_in(
                                     "New Chat",
-                                    &NewContext,
+                                    &NewChat,
                                     &focus_handle,
                                     window,
                                     cx,
@@ -256,7 +256,7 @@ impl AssistantPanel {
                                 let focus_handle = _pane.focus_handle(cx);
                                 Some(ContextMenu::build(window, cx, move |menu, _, _| {
                                     menu.context(focus_handle.clone())
-                                        .action("New Chat", Box::new(NewContext))
+                                        .action("New Chat", Box::new(NewChat))
                                         .action("History", Box::new(DeployHistory))
                                         .action("Prompt Library", Box::new(DeployPromptLibrary))
                                         .action("Configure", Box::new(ShowConfiguration))
@@ -760,7 +760,7 @@ impl AssistantPanel {
 
     pub fn create_new_context(
         workspace: &mut Workspace,
-        _: &NewContext,
+        _: &NewChat,
         window: &mut Window,
         cx: &mut Context<Workspace>,
     ) {
@@ -978,7 +978,7 @@ impl AssistantPanel {
                             .active_provider()
                             .map_or(true, |p| p.id() != provider.id())
                         {
-                            if let Some(model) = provider.provided_models(cx).first().cloned() {
+                            if let Some(model) = provider.default_model(cx) {
                                 update_settings_file::<AssistantSettings>(
                                     this.fs.clone(),
                                     cx,
@@ -1206,7 +1206,7 @@ impl Render for AssistantPanel {
         v_flex()
             .key_context("AssistantPanel")
             .size_full()
-            .on_action(cx.listener(|this, _: &NewContext, window, cx| {
+            .on_action(cx.listener(|this, _: &NewChat, window, cx| {
                 this.new_context(window, cx);
             }))
             .on_action(cx.listener(|this, _: &ShowConfiguration, window, cx| {

crates/assistant/src/inline_assistant.rs

@@ -32,11 +32,10 @@ use gpui::{
 };
 use language::{line_diff, Buffer, IndentKind, Point, Selection, TransactionId};
 use language_model::{
-    LanguageModel, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage,
-    LanguageModelTextStream, Role,
+    report_assistant_event, LanguageModel, LanguageModelRegistry, LanguageModelRequest,
+    LanguageModelRequestMessage, LanguageModelTextStream, Role,
 };
 use language_model_selector::{LanguageModelSelector, LanguageModelSelectorPopoverMenu};
-use language_models::report_assistant_event;
 use multi_buffer::MultiBufferRow;
 use parking_lot::Mutex;
 use project::{CodeAction, ProjectTransaction};

crates/assistant/src/terminal_inline_assistant.rs

@@ -16,10 +16,10 @@ use gpui::{
 };
 use language::Buffer;
 use language_model::{
-    LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage, Role,
+    report_assistant_event, LanguageModelRegistry, LanguageModelRequest,
+    LanguageModelRequestMessage, Role,
 };
 use language_model_selector::{LanguageModelSelector, LanguageModelSelectorPopoverMenu};
-use language_models::report_assistant_event;
 use prompt_library::PromptBuilder;
 use settings::{update_settings_file, Settings};
 use std::{

crates/assistant2/Cargo.toml

@@ -46,7 +46,6 @@ itertools.workspace = true
 language.workspace = true
 language_model.workspace = true
 language_model_selector.workspace = true
-language_models.workspace = true
 log.workspace = true
 lsp.workspace = true
 markdown.workspace = true

crates/assistant2/src/assistant_panel.rs

@@ -431,7 +431,7 @@ impl AssistantPanel {
                         active_provider.id() != provider.id()
                     })
                 {
-                    if let Some(model) = provider.provided_models(cx).first().cloned() {
+                    if let Some(model) = provider.default_model(cx) {
                         update_settings_file::<AssistantSettings>(
                             self.fs.clone(),
                             cx,

crates/assistant2/src/buffer_codegen.rs

@@ -9,10 +9,9 @@ use futures::{channel::mpsc, future::LocalBoxFuture, join, SinkExt, Stream, Stre
 use gpui::{App, AppContext as _, Context, Entity, EventEmitter, Subscription, Task};
 use language::{line_diff, Buffer, IndentKind, Point, TransactionId};
 use language_model::{
-    LanguageModel, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage,
-    LanguageModelTextStream, Role,
+    report_assistant_event, LanguageModel, LanguageModelRegistry, LanguageModelRequest,
+    LanguageModelRequestMessage, LanguageModelTextStream, Role,
 };
-use language_models::report_assistant_event;
 use multi_buffer::MultiBufferRow;
 use parking_lot::Mutex;
 use prompt_library::PromptBuilder;

crates/assistant2/src/inline_assistant.rs

@@ -24,8 +24,7 @@ use gpui::{
     UpdateGlobal, WeakEntity, Window,
 };
 use language::{Buffer, Point, Selection, TransactionId};
-use language_model::LanguageModelRegistry;
-use language_models::report_assistant_event;
+use language_model::{report_assistant_event, LanguageModelRegistry};
 use multi_buffer::MultiBufferRow;
 use parking_lot::Mutex;
 use project::{CodeAction, ProjectTransaction};

crates/assistant2/src/terminal_codegen.rs

@@ -2,8 +2,7 @@ use crate::inline_prompt_editor::CodegenStatus;
 use client::telemetry::Telemetry;
 use futures::{channel::mpsc, SinkExt, StreamExt};
 use gpui::{App, AppContext as _, Context, Entity, EventEmitter, Task};
-use language_model::{LanguageModelRegistry, LanguageModelRequest};
-use language_models::report_assistant_event;
+use language_model::{report_assistant_event, LanguageModelRegistry, LanguageModelRequest};
 use std::{sync::Arc, time::Instant};
 use telemetry_events::{AssistantEvent, AssistantKind, AssistantPhase};
 use terminal::Terminal;

crates/assistant2/src/terminal_inline_assistant.rs

@@ -13,9 +13,9 @@ use fs::Fs;
 use gpui::{App, Entity, Focusable, Global, Subscription, UpdateGlobal, WeakEntity};
 use language::Buffer;
 use language_model::{
-    LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage, Role,
+    report_assistant_event, LanguageModelRegistry, LanguageModelRequest,
+    LanguageModelRequestMessage, Role,
 };
-use language_models::report_assistant_event;
 use prompt_library::PromptBuilder;
 use std::sync::Arc;
 use telemetry_events::{AssistantEvent, AssistantKind, AssistantPhase};

crates/assistant2/src/thread.rs

@@ -10,9 +10,9 @@ use gpui::{App, Context, EventEmitter, SharedString, Task};
 use language_model::{
     LanguageModel, LanguageModelCompletionEvent, LanguageModelRegistry, LanguageModelRequest,
     LanguageModelRequestMessage, LanguageModelToolResult, LanguageModelToolUse,
-    LanguageModelToolUseId, MessageContent, Role, StopReason,
+    LanguageModelToolUseId, MaxMonthlySpendReachedError, MessageContent, PaymentRequiredError,
+    Role, StopReason,
 };
-use language_models::provider::cloud::{MaxMonthlySpendReachedError, PaymentRequiredError};
 use serde::{Deserialize, Serialize};
 use util::{post_inc, TryFutureExt as _};
 use uuid::Uuid;

crates/assistant_context_editor/Cargo.toml

@@ -30,7 +30,6 @@ indexed_docs.workspace = true
 language.workspace = true
 language_model.workspace = true
 language_model_selector.workspace = true
-language_models.workspace = true
 log.workspace = true
 multi_buffer.workspace = true
 open_ai.workspace = true

crates/assistant_context_editor/src/context.rs

@@ -19,13 +19,10 @@ use gpui::{
 };
 use language::{AnchorRangeExt, Bias, Buffer, LanguageRegistry, OffsetRangeExt, Point, ToOffset};
 use language_model::{
-    LanguageModel, LanguageModelCacheConfiguration, LanguageModelCompletionEvent,
-    LanguageModelImage, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage,
-    LanguageModelToolUseId, MessageContent, Role, StopReason,
-};
-use language_models::{
-    provider::cloud::{MaxMonthlySpendReachedError, PaymentRequiredError},
-    report_assistant_event,
+    report_assistant_event, LanguageModel, LanguageModelCacheConfiguration,
+    LanguageModelCompletionEvent, LanguageModelImage, LanguageModelRegistry, LanguageModelRequest,
+    LanguageModelRequestMessage, LanguageModelToolUseId, MaxMonthlySpendReachedError,
+    MessageContent, PaymentRequiredError, Role, StopReason,
 };
 use open_ai::Model as OpenAiModel;
 use paths::contexts_dir;

crates/assistant_context_editor/src/context_editor.rs

@@ -1234,8 +1234,8 @@ impl ContextEditor {
                     .px_1()
                     .mr_0p5()
                     .border_1()
-                    .border_color(theme::color_alpha(colors.border_variant, 0.6))
-                    .bg(theme::color_alpha(colors.element_background, 0.6))
+                    .border_color(colors.border_variant.alpha(0.6))
+                    .bg(colors.element_background.alpha(0.6))
                     .child("esc"),
             )
             .child("to cancel")
@@ -1514,15 +1514,11 @@ impl ContextEditor {
 
                 (!text.is_empty()).then_some((text, true))
             } else {
-                let anchor = context_editor.selections.newest_anchor();
-                let text = context_editor
-                    .buffer()
-                    .read(cx)
-                    .read(cx)
-                    .text_for_range(anchor.range())
-                    .collect::<String>();
+                let selection = context_editor.selections.newest_adjusted(cx);
+                let buffer = context_editor.buffer().read(cx).snapshot(cx);
+                let selected_text = buffer.text_for_range(selection.range()).collect::<String>();
 
-                (!text.is_empty()).then_some((text, false))
+                (!selected_text.is_empty()).then_some((selected_text, false))
             }
         })
     }
@@ -1777,23 +1773,16 @@ impl ContextEditor {
         &mut self,
         cx: &mut Context<Self>,
     ) -> (String, CopyMetadata, Vec<text::Selection<usize>>) {
-        let (snapshot, selection, creases) = self.editor.update(cx, |editor, cx| {
-            let mut selection = editor.selections.newest::<Point>(cx);
+        let (selection, creases) = self.editor.update(cx, |editor, cx| {
+            let mut selection = editor.selections.newest_adjusted(cx);
             let snapshot = editor.buffer().read(cx).snapshot(cx);
 
-            let is_entire_line = selection.is_empty() || editor.selections.line_mode;
-            if is_entire_line {
-                selection.start = Point::new(selection.start.row, 0);
-                selection.end =
-                    cmp::min(snapshot.max_point(), Point::new(selection.start.row + 1, 0));
-                selection.goal = SelectionGoal::None;
-            }
+            selection.goal = SelectionGoal::None;
 
             let selection_start = snapshot.point_to_offset(selection.start);
 
             (
-                snapshot.clone(),
-                selection.clone(),
+                selection.map(|point| snapshot.point_to_offset(point)),
                 editor.display_map.update(cx, |display_map, cx| {
                     display_map
                         .snapshot(cx)
@@ -1833,7 +1822,6 @@ impl ContextEditor {
             )
         });
 
-        let selection = selection.map(|point| snapshot.point_to_offset(point));
         let context = self.context.read(cx);
 
         let mut text = String::new();

crates/assistant_settings/src/assistant_settings.rs

@@ -359,6 +359,7 @@ fn providers_schema(_: &mut schemars::gen::SchemaGenerator) -> schemars::schema:
     schemars::schema::SchemaObject {
         enum_values: Some(vec![
             "anthropic".into(),
+            "bedrock".into(),
             "google".into(),
             "lmstudio".into(),
             "ollama".into(),
@@ -512,7 +513,7 @@ mod tests {
                 AssistantSettings::get_global(cx).default_model,
                 LanguageModelSelection {
                     provider: "zed.dev".into(),
-                    model: "claude-3-5-sonnet".into(),
+                    model: "claude-3-5-sonnet-latest".into(),
                 }
             );
         });

crates/assistant_tools/src/now_tool.rs

@@ -17,7 +17,7 @@ pub enum Timezone {
 }
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
-pub struct FileToolInput {
+pub struct NowToolInput {
     /// The timezone to use for the datetime.
     timezone: Timezone,
 }
@@ -34,7 +34,7 @@ impl Tool for NowTool {
     }
 
     fn input_schema(&self) -> serde_json::Value {
-        let schema = schemars::schema_for!(FileToolInput);
+        let schema = schemars::schema_for!(NowToolInput);
         serde_json::to_value(&schema).unwrap()
     }
 
@@ -45,7 +45,7 @@ impl Tool for NowTool {
         _window: &mut Window,
         _cx: &mut App,
     ) -> Task<Result<String>> {
-        let input: FileToolInput = match serde_json::from_value(input) {
+        let input: NowToolInput = match serde_json::from_value(input) {
             Ok(input) => input,
             Err(err) => return Task::ready(Err(anyhow!(err))),
         };

crates/aws_http_client/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "aws_http_client"
+version = "0.1.0"
+edition.workspace = true
+publish.workspace = true
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/aws_http_client.rs"
+
+[features]
+default = []
+
+[dependencies]
+aws-smithy-runtime-api.workspace = true
+aws-smithy-types.workspace = true
+futures.workspace = true
+http_client.workspace = true
+tokio = { workspace = true, features = ["rt", "rt-multi-thread"] }

crates/aws_http_client/LICENSE-GPL

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

crates/aws_http_client/src/aws_http_client.rs

@@ -0,0 +1,118 @@
+use std::fmt;
+use std::sync::Arc;
+
+use aws_smithy_runtime_api::client::http::{
+    HttpClient as AwsClient, HttpConnector as AwsConnector,
+    HttpConnectorFuture as AwsConnectorFuture, HttpConnectorFuture, HttpConnectorSettings,
+    SharedHttpConnector,
+};
+use aws_smithy_runtime_api::client::orchestrator::{HttpRequest as AwsHttpRequest, HttpResponse};
+use aws_smithy_runtime_api::client::result::ConnectorError;
+use aws_smithy_runtime_api::client::runtime_components::RuntimeComponents;
+use aws_smithy_runtime_api::http::StatusCode;
+use aws_smithy_types::body::SdkBody;
+use futures::AsyncReadExt;
+use http_client::{AsyncBody, Inner};
+use http_client::{HttpClient, Request};
+use tokio::runtime::Handle;
+
+struct AwsHttpConnector {
+    client: Arc<dyn HttpClient>,
+    handle: Handle,
+}
+
+impl std::fmt::Debug for AwsHttpConnector {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("AwsHttpConnector").finish()
+    }
+}
+
+impl AwsConnector for AwsHttpConnector {
+    fn call(&self, request: AwsHttpRequest) -> AwsConnectorFuture {
+        let req = match request.try_into_http1x() {
+            Ok(req) => req,
+            Err(err) => {
+                return HttpConnectorFuture::ready(Err(ConnectorError::other(err.into(), None)))
+            }
+        };
+
+        let (parts, body) = req.into_parts();
+
+        let response = self
+            .client
+            .send(Request::from_parts(parts, convert_to_async_body(body)));
+
+        let handle = self.handle.clone();
+
+        HttpConnectorFuture::new(async move {
+            let response = match response.await {
+                Ok(response) => response,
+                Err(err) => return Err(ConnectorError::other(err.into(), None)),
+            };
+            let (parts, body) = response.into_parts();
+            let body = convert_to_sdk_body(body, handle).await;
+
+            Ok(HttpResponse::new(
+                StatusCode::try_from(parts.status.as_u16()).unwrap(),
+                body,
+            ))
+        })
+    }
+}
+
+#[derive(Clone)]
+pub struct AwsHttpClient {
+    client: Arc<dyn HttpClient>,
+    handler: Handle,
+}
+
+impl std::fmt::Debug for AwsHttpClient {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("AwsHttpClient").finish()
+    }
+}
+
+impl AwsHttpClient {
+    pub fn new(client: Arc<dyn HttpClient>, handle: Handle) -> Self {
+        Self {
+            client,
+            handler: handle,
+        }
+    }
+}
+
+impl AwsClient for AwsHttpClient {
+    fn http_connector(
+        &self,
+        _settings: &HttpConnectorSettings,
+        _components: &RuntimeComponents,
+    ) -> SharedHttpConnector {
+        SharedHttpConnector::new(AwsHttpConnector {
+            client: self.client.clone(),
+            handle: self.handler.clone(),
+        })
+    }
+}
+
+pub async fn convert_to_sdk_body(body: AsyncBody, handle: Handle) -> SdkBody {
+    match body.0 {
+        Inner::Empty => SdkBody::empty(),
+        Inner::Bytes(bytes) => SdkBody::from(bytes.into_inner()),
+        Inner::AsyncReader(mut reader) => {
+            let buffer = handle.spawn(async move {
+                let mut buffer = Vec::new();
+                let _ = reader.read_to_end(&mut buffer).await;
+                buffer
+            });
+
+            SdkBody::from(buffer.await.unwrap_or_default())
+        }
+    }
+}
+
+pub fn convert_to_async_body(body: SdkBody) -> AsyncBody {
+    match body.bytes() {
+        Some(bytes) => AsyncBody::from((*bytes).to_vec()),
+        None => AsyncBody::empty(),
+    }
+}

crates/bedrock/Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "bedrock"
+version = "0.1.0"
+edition.workspace = true
+publish.workspace = true
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/bedrock.rs"
+
+[features]
+default = []
+schemars = ["dep:schemars"]
+
+[dependencies]
+anyhow.workspace = true
+aws-sdk-bedrockruntime = { workspace = true, features = ["behavior-version-latest"] }
+aws-smithy-types = {workspace = true}
+futures.workspace = true
+schemars = { workspace = true, optional = true }
+serde.workspace = true
+serde_json.workspace = true
+strum.workspace = true
+thiserror.workspace = true
+tokio = { workspace = true, features = ["rt", "rt-multi-thread"] }

crates/bedrock/LICENSE-GPL

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

crates/bedrock/src/bedrock.rs

@@ -0,0 +1,166 @@
+mod models;
+
+use std::pin::Pin;
+
+use anyhow::{anyhow, Context, Error, Result};
+use aws_sdk_bedrockruntime as bedrock;
+pub use aws_sdk_bedrockruntime as bedrock_client;
+pub use aws_sdk_bedrockruntime::types::{
+    ContentBlock as BedrockInnerContent, SpecificToolChoice as BedrockSpecificTool,
+    ToolChoice as BedrockToolChoice, ToolInputSchema as BedrockToolInputSchema,
+    ToolSpecification as BedrockTool,
+};
+use aws_smithy_types::{Document, Number as AwsNumber};
+pub use bedrock::operation::converse_stream::ConverseStreamInput as BedrockStreamingRequest;
+pub use bedrock::types::{
+    ContentBlock as BedrockRequestContent, ConversationRole as BedrockRole,
+    ConverseOutput as BedrockResponse, ConverseStreamOutput as BedrockStreamingResponse,
+    Message as BedrockMessage, ResponseStream as BedrockResponseStream,
+};
+use futures::stream::{self, BoxStream, Stream};
+use serde::{Deserialize, Serialize};
+use serde_json::{Number, Value};
+use thiserror::Error;
+
+pub use crate::models::*;
+
+pub async fn complete(
+    client: &bedrock::Client,
+    request: Request,
+) -> Result<BedrockResponse, BedrockError> {
+    let response = bedrock::Client::converse(client)
+        .model_id(request.model.clone())
+        .set_messages(request.messages.into())
+        .send()
+        .await
+        .context("failed to send request to Bedrock");
+
+    match response {
+        Ok(output) => output
+            .output
+            .ok_or_else(|| BedrockError::Other(anyhow!("no output"))),
+        Err(err) => Err(BedrockError::Other(err)),
+    }
+}
+
+pub async fn stream_completion(
+    client: bedrock::Client,
+    request: Request,
+    handle: tokio::runtime::Handle,
+) -> Result<BoxStream<'static, Result<BedrockStreamingResponse, BedrockError>>, Error> {
+    handle
+        .spawn(async move {
+            let response = bedrock::Client::converse_stream(&client)
+                .model_id(request.model.clone())
+                .set_messages(request.messages.into())
+                .send()
+                .await;
+
+            match response {
+                Ok(output) => {
+                    let stream: Pin<
+                        Box<
+                            dyn Stream<Item = Result<BedrockStreamingResponse, BedrockError>>
+                                + Send,
+                        >,
+                    > = Box::pin(stream::unfold(output.stream, |mut stream| async move {
+                        match stream.recv().await {
+                            Ok(Some(output)) => Some((Ok(output), stream)),
+                            Ok(None) => None,
+                            Err(err) => {
+                                Some((
+                                    // TODO: Figure out how we can capture Throttling Exceptions
+                                    Err(BedrockError::ClientError(anyhow!(
+                                        "{:?}",
+                                        aws_sdk_bedrockruntime::error::DisplayErrorContext(err)
+                                    ))),
+                                    stream,
+                                ))
+                            }
+                        }
+                    }));
+                    Ok(stream)
+                }
+                Err(err) => Err(anyhow!(
+                    "{:?}",
+                    aws_sdk_bedrockruntime::error::DisplayErrorContext(err)
+                )),
+            }
+        })
+        .await
+        .map_err(|err| anyhow!("failed to spawn task: {err:?}"))?
+}
+
+pub fn aws_document_to_value(document: &Document) -> Value {
+    match document {
+        Document::Null => Value::Null,
+        Document::Bool(value) => Value::Bool(*value),
+        Document::Number(value) => match *value {
+            AwsNumber::PosInt(value) => Value::Number(Number::from(value)),
+            AwsNumber::NegInt(value) => Value::Number(Number::from(value)),
+            AwsNumber::Float(value) => Value::Number(Number::from_f64(value).unwrap()),
+        },
+        Document::String(value) => Value::String(value.clone()),
+        Document::Array(array) => Value::Array(array.iter().map(aws_document_to_value).collect()),
+        Document::Object(map) => Value::Object(
+            map.iter()
+                .map(|(key, value)| (key.clone(), aws_document_to_value(value)))
+                .collect(),
+        ),
+    }
+}
+
+pub fn value_to_aws_document(value: &Value) -> Document {
+    match value {
+        Value::Null => Document::Null,
+        Value::Bool(value) => Document::Bool(*value),
+        Value::Number(value) => {
+            if let Some(value) = value.as_u64() {
+                Document::Number(AwsNumber::PosInt(value))
+            } else if let Some(value) = value.as_i64() {
+                Document::Number(AwsNumber::NegInt(value))
+            } else if let Some(value) = value.as_f64() {
+                Document::Number(AwsNumber::Float(value))
+            } else {
+                Document::Null
+            }
+        }
+        Value::String(value) => Document::String(value.clone()),
+        Value::Array(array) => Document::Array(array.iter().map(value_to_aws_document).collect()),
+        Value::Object(map) => Document::Object(
+            map.iter()
+                .map(|(key, value)| (key.clone(), value_to_aws_document(value)))
+                .collect(),
+        ),
+    }
+}
+
+#[derive(Debug)]
+pub struct Request {
+    pub model: String,
+    pub max_tokens: u32,
+    pub messages: Vec<BedrockMessage>,
+    pub tools: Vec<BedrockTool>,
+    pub tool_choice: Option<BedrockToolChoice>,
+    pub system: Option<String>,
+    pub metadata: Option<Metadata>,
+    pub stop_sequences: Vec<String>,
+    pub temperature: Option<f32>,
+    pub top_k: Option<u32>,
+    pub top_p: Option<f32>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Metadata {
+    pub user_id: Option<String>,
+}
+
+#[derive(Error, Debug)]
+pub enum BedrockError {
+    #[error("client error: {0}")]
+    ClientError(anyhow::Error),
+    #[error("extension error: {0}")]
+    ExtensionError(anyhow::Error),
+    #[error(transparent)]
+    Other(#[from] anyhow::Error),
+}

crates/bedrock/src/models.rs

@@ -0,0 +1,199 @@
+use anyhow::anyhow;
+use serde::{Deserialize, Serialize};
+use strum::EnumIter;
+
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, EnumIter)]
+pub enum Model {
+    // Anthropic models (already included)
+    #[default]
+    #[serde(rename = "claude-3-5-sonnet", alias = "claude-3-5-sonnet-latest")]
+    Claude3_5Sonnet,
+    #[serde(rename = "claude-3-opus", alias = "claude-3-opus-latest")]
+    Claude3Opus,
+    #[serde(rename = "claude-3-sonnet", alias = "claude-3-sonnet-latest")]
+    Claude3Sonnet,
+    #[serde(rename = "claude-3-5-haiku", alias = "claude-3-5-haiku-latest")]
+    Claude3_5Haiku,
+    // Amazon Nova Models
+    AmazonNovaLite,
+    AmazonNovaMicro,
+    AmazonNovaPro,
+    // AI21 models
+    AI21J2GrandeInstruct,
+    AI21J2JumboInstruct,
+    AI21J2Mid,
+    AI21J2MidV1,
+    AI21J2Ultra,
+    AI21J2UltraV1_8k,
+    AI21J2UltraV1,
+    AI21JambaInstructV1,
+    AI21Jamba15LargeV1,
+    AI21Jamba15MiniV1,
+    // Cohere models
+    CohereCommandTextV14_4k,
+    CohereCommandRV1,
+    CohereCommandRPlusV1,
+    CohereCommandLightTextV14_4k,
+    // Meta models
+    MetaLlama38BInstructV1,
+    MetaLlama370BInstructV1,
+    MetaLlama318BInstructV1_128k,
+    MetaLlama318BInstructV1,
+    MetaLlama3170BInstructV1_128k,
+    MetaLlama3170BInstructV1,
+    MetaLlama3211BInstructV1,
+    MetaLlama3290BInstructV1,
+    MetaLlama321BInstructV1,
+    MetaLlama323BInstructV1,
+    // Mistral models
+    MistralMistral7BInstructV0,
+    MistralMixtral8x7BInstructV0,
+    MistralMistralLarge2402V1,
+    MistralMistralSmall2402V1,
+    #[serde(rename = "custom")]
+    Custom {
+        name: String,
+        max_tokens: usize,
+        /// The name displayed in the UI, such as in the assistant panel model dropdown menu.
+        display_name: Option<String>,
+        max_output_tokens: Option<u32>,
+        default_temperature: Option<f32>,
+    },
+}
+
+impl Model {
+    pub fn from_id(id: &str) -> anyhow::Result<Self> {
+        if id.starts_with("claude-3-5-sonnet") {
+            Ok(Self::Claude3_5Sonnet)
+        } else if id.starts_with("claude-3-opus") {
+            Ok(Self::Claude3Opus)
+        } else if id.starts_with("claude-3-sonnet") {
+            Ok(Self::Claude3Sonnet)
+        } else if id.starts_with("claude-3-5-haiku") {
+            Ok(Self::Claude3_5Haiku)
+        } else {
+            Err(anyhow!("invalid model id"))
+        }
+    }
+
+    pub fn id(&self) -> &str {
+        match self {
+            Model::Claude3_5Sonnet => "us.anthropic.claude-3-5-sonnet-20241022-v2:0",
+            Model::Claude3Opus => "us.anthropic.claude-3-opus-20240229-v1:0",
+            Model::Claude3Sonnet => "us.anthropic.claude-3-sonnet-20240229-v1:0",
+            Model::Claude3_5Haiku => "us.anthropic.claude-3-5-haiku-20241022-v1:0",
+            Model::AmazonNovaLite => "us.amazon.nova-lite-v1:0",
+            Model::AmazonNovaMicro => "us.amazon.nova-micro-v1:0",
+            Model::AmazonNovaPro => "us.amazon.nova-pro-v1:0",
+            Model::AI21J2GrandeInstruct => "ai21.j2-grande-instruct",
+            Model::AI21J2JumboInstruct => "ai21.j2-jumbo-instruct",
+            Model::AI21J2Mid => "ai21.j2-mid",
+            Model::AI21J2MidV1 => "ai21.j2-mid-v1",
+            Model::AI21J2Ultra => "ai21.j2-ultra",
+            Model::AI21J2UltraV1_8k => "ai21.j2-ultra-v1:0:8k",
+            Model::AI21J2UltraV1 => "ai21.j2-ultra-v1",
+            Model::AI21JambaInstructV1 => "ai21.jamba-instruct-v1:0",
+            Model::AI21Jamba15LargeV1 => "ai21.jamba-1-5-large-v1:0",
+            Model::AI21Jamba15MiniV1 => "ai21.jamba-1-5-mini-v1:0",
+            Model::CohereCommandTextV14_4k => "cohere.command-text-v14:7:4k",
+            Model::CohereCommandRV1 => "cohere.command-r-v1:0",
+            Model::CohereCommandRPlusV1 => "cohere.command-r-plus-v1:0",
+            Model::CohereCommandLightTextV14_4k => "cohere.command-light-text-v14:7:4k",
+            Model::MetaLlama38BInstructV1 => "meta.llama3-8b-instruct-v1:0",
+            Model::MetaLlama370BInstructV1 => "meta.llama3-70b-instruct-v1:0",
+            Model::MetaLlama318BInstructV1_128k => "meta.llama3-1-8b-instruct-v1:0:128k",
+            Model::MetaLlama318BInstructV1 => "meta.llama3-1-8b-instruct-v1:0",
+            Model::MetaLlama3170BInstructV1_128k => "meta.llama3-1-70b-instruct-v1:0:128k",
+            Model::MetaLlama3170BInstructV1 => "meta.llama3-1-70b-instruct-v1:0",
+            Model::MetaLlama3211BInstructV1 => "meta.llama3-2-11b-instruct-v1:0",
+            Model::MetaLlama3290BInstructV1 => "meta.llama3-2-90b-instruct-v1:0",
+            Model::MetaLlama321BInstructV1 => "meta.llama3-2-1b-instruct-v1:0",
+            Model::MetaLlama323BInstructV1 => "meta.llama3-2-3b-instruct-v1:0",
+            Model::MistralMistral7BInstructV0 => "mistral.mistral-7b-instruct-v0:2",
+            Model::MistralMixtral8x7BInstructV0 => "mistral.mixtral-8x7b-instruct-v0:1",
+            Model::MistralMistralLarge2402V1 => "mistral.mistral-large-2402-v1:0",
+            Model::MistralMistralSmall2402V1 => "mistral.mistral-small-2402-v1:0",
+            Self::Custom { name, .. } => name,
+        }
+    }
+
+    pub fn display_name(&self) -> &str {
+        match self {
+            Self::Claude3_5Sonnet => "Claude 3.5 Sonnet",
+            Self::Claude3Opus => "Claude 3 Opus",
+            Self::Claude3Sonnet => "Claude 3 Sonnet",
+            Self::Claude3_5Haiku => "Claude 3.5 Haiku",
+            Self::AmazonNovaLite => "Amazon Nova Lite",
+            Self::AmazonNovaMicro => "Amazon Nova Micro",
+            Self::AmazonNovaPro => "Amazon Nova Pro",
+            Self::AI21J2GrandeInstruct => "AI21 Jurassic2 Grande Instruct",
+            Self::AI21J2JumboInstruct => "AI21 Jurassic2 Jumbo Instruct",
+            Self::AI21J2Mid => "AI21 Jurassic2 Mid",
+            Self::AI21J2MidV1 => "AI21 Jurassic2 Mid V1",
+            Self::AI21J2Ultra => "AI21 Jurassic2 Ultra",
+            Self::AI21J2UltraV1_8k => "AI21 Jurassic2 Ultra V1 8K",
+            Self::AI21J2UltraV1 => "AI21 Jurassic2 Ultra V1",
+            Self::AI21JambaInstructV1 => "AI21 Jamba Instruct",
+            Self::AI21Jamba15LargeV1 => "AI21 Jamba 1.5 Large",
+            Self::AI21Jamba15MiniV1 => "AI21 Jamba 1.5 Mini",
+            Self::CohereCommandTextV14_4k => "Cohere Command Text V14 4K",
+            Self::CohereCommandRV1 => "Cohere Command R V1",
+            Self::CohereCommandRPlusV1 => "Cohere Command R Plus V1",
+            Self::CohereCommandLightTextV14_4k => "Cohere Command Light Text V14 4K",
+            Self::MetaLlama38BInstructV1 => "Meta Llama 3 8B Instruct V1",
+            Self::MetaLlama370BInstructV1 => "Meta Llama 3 70B Instruct V1",
+            Self::MetaLlama318BInstructV1_128k => "Meta Llama 3 1.8B Instruct V1 128K",
+            Self::MetaLlama318BInstructV1 => "Meta Llama 3 1.8B Instruct V1",
+            Self::MetaLlama3170BInstructV1_128k => "Meta Llama 3 1 70B Instruct V1 128K",
+            Self::MetaLlama3170BInstructV1 => "Meta Llama 3 1 70B Instruct V1",
+            Self::MetaLlama3211BInstructV1 => "Meta Llama 3 2 11B Instruct V1",
+            Self::MetaLlama3290BInstructV1 => "Meta Llama 3 2 90B Instruct V1",
+            Self::MetaLlama321BInstructV1 => "Meta Llama 3 2 1B Instruct V1",
+            Self::MetaLlama323BInstructV1 => "Meta Llama 3 2 3B Instruct V1",
+            Self::MistralMistral7BInstructV0 => "Mistral 7B Instruct V0",
+            Self::MistralMixtral8x7BInstructV0 => "Mistral Mixtral 8x7B Instruct V0",
+            Self::MistralMistralLarge2402V1 => "Mistral Large 2402 V1",
+            Self::MistralMistralSmall2402V1 => "Mistral Small 2402 V1",
+            Self::Custom {
+                display_name, name, ..
+            } => display_name.as_deref().unwrap_or(name),
+        }
+    }
+
+    pub fn max_token_count(&self) -> usize {
+        match self {
+            Self::Claude3_5Sonnet
+            | Self::Claude3Opus
+            | Self::Claude3Sonnet
+            | Self::Claude3_5Haiku => 200_000,
+            Self::Custom { max_tokens, .. } => *max_tokens,
+            _ => 200_000,
+        }
+    }
+
+    pub fn max_output_tokens(&self) -> u32 {
+        match self {
+            Self::Claude3Opus | Self::Claude3Sonnet | Self::Claude3_5Haiku => 4_096,
+            Self::Claude3_5Sonnet => 8_192,
+            Self::Custom {
+                max_output_tokens, ..
+            } => max_output_tokens.unwrap_or(4_096),
+            _ => 4_096,
+        }
+    }
+
+    pub fn default_temperature(&self) -> f32 {
+        match self {
+            Self::Claude3_5Sonnet
+            | Self::Claude3Opus
+            | Self::Claude3Sonnet
+            | Self::Claude3_5Haiku => 1.0,
+            Self::Custom {
+                default_temperature,
+                ..
+            } => default_temperature.unwrap_or(1.0),
+            _ => 1.0,
+        }
+    }
+}

crates/buffer_diff/src/buffer_diff.rs

@@ -3,7 +3,8 @@ use git2::{DiffLineType as GitDiffLineType, DiffOptions as GitOptions, Patch as
 use gpui::{App, AppContext as _, AsyncApp, Context, Entity, EventEmitter};
 use language::{Language, LanguageRegistry};
 use rope::Rope;
-use std::{cmp, future::Future, iter, ops::Range, sync::Arc};
+use std::cmp::Ordering;
+use std::{future::Future, iter, ops::Range, sync::Arc};
 use sum_tree::SumTree;
 use text::ToOffset as _;
 use text::{Anchor, Bias, BufferId, OffsetRangeExt, Point};
@@ -68,7 +69,6 @@ pub struct DiffHunk {
     /// The range in the buffer's diff base text to which this hunk corresponds.
     pub diff_base_byte_range: Range<usize>,
     pub secondary_status: DiffHunkSecondaryStatus,
-    pub secondary_diff_base_byte_range: Option<Range<usize>>,
 }
 
 /// We store [`InternalDiffHunk`]s internally so we don't need to store the additional row range.
@@ -110,12 +110,17 @@ impl sum_tree::Summary for DiffHunkSummary {
 }
 
 impl<'a> sum_tree::SeekTarget<'a, DiffHunkSummary, DiffHunkSummary> for Anchor {
-    fn cmp(
-        &self,
-        cursor_location: &DiffHunkSummary,
-        buffer: &text::BufferSnapshot,
-    ) -> cmp::Ordering {
-        self.cmp(&cursor_location.buffer_range.end, buffer)
+    fn cmp(&self, cursor_location: &DiffHunkSummary, buffer: &text::BufferSnapshot) -> Ordering {
+        if self
+            .cmp(&cursor_location.buffer_range.start, buffer)
+            .is_lt()
+        {
+            Ordering::Less
+        } else if self.cmp(&cursor_location.buffer_range.end, buffer).is_gt() {
+            Ordering::Greater
+        } else {
+            Ordering::Equal
+        }
     }
 }
 
@@ -171,97 +176,96 @@ impl BufferDiffSnapshot {
         }
     }
 
-    fn buffer_range_to_unchanged_diff_base_range(
-        &self,
-        buffer_range: Range<Anchor>,
-        buffer: &text::BufferSnapshot,
-    ) -> Option<Range<usize>> {
-        let mut hunks = self.inner.hunks.iter();
-        let mut start = 0;
-        let mut pos = buffer.anchor_before(0);
-        while let Some(hunk) = hunks.next() {
-            assert!(buffer_range.start.cmp(&pos, buffer).is_ge());
-            assert!(hunk.buffer_range.start.cmp(&pos, buffer).is_ge());
-            if hunk
-                .buffer_range
-                .start
-                .cmp(&buffer_range.end, buffer)
-                .is_ge()
-            {
-                // target buffer range is contained in the unchanged stretch leading up to this next hunk,
-                // so do a final adjustment based on that
-                break;
-            }
-
-            // if the target buffer range intersects this hunk at all, no dice
-            if buffer_range
-                .start
-                .cmp(&hunk.buffer_range.end, buffer)
-                .is_lt()
-            {
-                return None;
-            }
-
-            start += hunk.buffer_range.start.to_offset(buffer) - pos.to_offset(buffer);
-            start += hunk.diff_base_byte_range.end - hunk.diff_base_byte_range.start;
-            pos = hunk.buffer_range.end;
-        }
-        start += buffer_range.start.to_offset(buffer) - pos.to_offset(buffer);
-        let end = start + buffer_range.end.to_offset(buffer) - buffer_range.start.to_offset(buffer);
-        Some(start..end)
-    }
-
-    pub fn secondary_edits_for_stage_or_unstage(
+    pub fn new_secondary_text_for_stage_or_unstage(
         &self,
         stage: bool,
-        hunks: impl Iterator<Item = (Range<usize>, Option<Range<usize>>, Range<Anchor>)>,
+        hunks: impl Iterator<Item = (Range<Anchor>, Range<usize>)>,
         buffer: &text::BufferSnapshot,
-    ) -> Vec<(Range<usize>, String)> {
-        let Some(secondary_diff) = self.secondary_diff() else {
-            log::debug!("no secondary diff");
-            return Vec::new();
+        cx: &mut App,
+    ) -> Option<Rope> {
+        let secondary_diff = self.secondary_diff()?;
+        let index_base = if let Some(index_base) = secondary_diff.base_text() {
+            index_base.text.as_rope().clone()
+        } else if stage {
+            Rope::from("")
+        } else {
+            return None;
         };
-        let index_base = secondary_diff.base_text().map_or_else(
-            || Rope::from(""),
-            |snapshot| snapshot.text.as_rope().clone(),
-        );
         let head_base = self.base_text().map_or_else(
             || Rope::from(""),
             |snapshot| snapshot.text.as_rope().clone(),
         );
-        log::debug!("original: {:?}", index_base.to_string());
+
+        let mut secondary_cursor = secondary_diff.inner.hunks.cursor::<DiffHunkSummary>(buffer);
+        secondary_cursor.next(buffer);
         let mut edits = Vec::new();
-        for (diff_base_byte_range, secondary_diff_base_byte_range, buffer_range) in hunks {
-            let (index_byte_range, replacement_text) = if stage {
+        let mut prev_secondary_hunk_buffer_offset = 0;
+        let mut prev_secondary_hunk_base_text_offset = 0;
+        for (buffer_range, diff_base_byte_range) in hunks {
+            let skipped_hunks = secondary_cursor.slice(&buffer_range.start, Bias::Left, buffer);
+
+            if let Some(secondary_hunk) = skipped_hunks.last() {
+                prev_secondary_hunk_base_text_offset = secondary_hunk.diff_base_byte_range.end;
+                prev_secondary_hunk_buffer_offset =
+                    secondary_hunk.buffer_range.end.to_offset(buffer);
+            }
+
+            let mut buffer_offset_range = buffer_range.to_offset(buffer);
+            let start_overshoot = buffer_offset_range.start - prev_secondary_hunk_buffer_offset;
+            let mut secondary_base_text_start =
+                prev_secondary_hunk_base_text_offset + start_overshoot;
+
+            while let Some(secondary_hunk) = secondary_cursor.item().filter(|item| {
+                item.buffer_range
+                    .start
+                    .cmp(&buffer_range.end, buffer)
+                    .is_le()
+            }) {
+                let secondary_hunk_offset_range = secondary_hunk.buffer_range.to_offset(buffer);
+                prev_secondary_hunk_base_text_offset = secondary_hunk.diff_base_byte_range.end;
+                prev_secondary_hunk_buffer_offset = secondary_hunk_offset_range.end;
+
+                secondary_base_text_start =
+                    secondary_base_text_start.min(secondary_hunk.diff_base_byte_range.start);
+                buffer_offset_range.start = buffer_offset_range
+                    .start
+                    .min(secondary_hunk_offset_range.start);
+
+                secondary_cursor.next(buffer);
+            }
+
+            let end_overshoot = buffer_offset_range
+                .end
+                .saturating_sub(prev_secondary_hunk_buffer_offset);
+            let secondary_base_text_end = prev_secondary_hunk_base_text_offset + end_overshoot;
+
+            let secondary_base_text_range = secondary_base_text_start..secondary_base_text_end;
+            buffer_offset_range.end = buffer_offset_range
+                .end
+                .max(prev_secondary_hunk_buffer_offset);
+
+            let replacement_text = if stage {
                 log::debug!("staging");
-                let mut replacement_text = String::new();
-                let Some(index_byte_range) = secondary_diff_base_byte_range.clone() else {
-                    log::debug!("not a stageable hunk");
-                    continue;
-                };
-                log::debug!("using {:?}", index_byte_range);
-                for chunk in buffer.text_for_range(buffer_range.clone()) {
-                    replacement_text.push_str(chunk);
-                }
-                (index_byte_range, replacement_text)
+                buffer
+                    .text_for_range(buffer_offset_range)
+                    .collect::<String>()
             } else {
                 log::debug!("unstaging");
-                let mut replacement_text = String::new();
-                let Some(index_byte_range) = secondary_diff
-                    .buffer_range_to_unchanged_diff_base_range(buffer_range.clone(), &buffer)
-                else {
-                    log::debug!("not an unstageable hunk");
-                    continue;
-                };
-                for chunk in head_base.chunks_in_range(diff_base_byte_range.clone()) {
-                    replacement_text.push_str(chunk);
-                }
-                (index_byte_range, replacement_text)
+                head_base
+                    .chunks_in_range(diff_base_byte_range.clone())
+                    .collect::<String>()
             };
-            edits.push((index_byte_range, replacement_text));
+            edits.push((secondary_base_text_range, replacement_text));
         }
-        log::debug!("edits: {edits:?}");
-        edits
+
+        let buffer = cx.new(|cx| {
+            language::Buffer::local_normalized(index_base, text::LineEnding::default(), cx)
+        });
+        let new_text = buffer.update(cx, |buffer, cx| {
+            buffer.edit(edits, None, cx);
+            buffer.as_rope().clone()
+        });
+        Some(new_text)
     }
 }
 
@@ -322,13 +326,12 @@ impl BufferDiffInner {
             }
 
             let mut secondary_status = DiffHunkSecondaryStatus::None;
-            let mut secondary_diff_base_byte_range = None;
             if let Some(secondary_cursor) = secondary_cursor.as_mut() {
                 if start_anchor
                     .cmp(&secondary_cursor.start().buffer_range.start, buffer)
                     .is_gt()
                 {
-                    secondary_cursor.seek_forward(&end_anchor, Bias::Left, buffer);
+                    secondary_cursor.seek_forward(&start_anchor, Bias::Left, buffer);
                 }
 
                 if let Some(secondary_hunk) = secondary_cursor.item() {
@@ -339,12 +342,12 @@ impl BufferDiffInner {
                     }
                     if secondary_range == (start_point..end_point) {
                         secondary_status = DiffHunkSecondaryStatus::HasSecondaryHunk;
-                        secondary_diff_base_byte_range =
-                            Some(secondary_hunk.diff_base_byte_range.clone());
                     } else if secondary_range.start <= end_point {
                         secondary_status = DiffHunkSecondaryStatus::OverlapsWithSecondaryHunk;
                     }
                 }
+            } else {
+                log::debug!("no secondary cursor!!");
             }
 
             return Some(DiffHunk {
@@ -352,7 +355,6 @@ impl BufferDiffInner {
                 diff_base_byte_range: start_base..end_base,
                 buffer_range: start_anchor..end_anchor,
                 secondary_status,
-                secondary_diff_base_byte_range,
             });
         })
     }
@@ -387,7 +389,6 @@ impl BufferDiffInner {
                 buffer_range: hunk.buffer_range.clone(),
                 // The secondary status is not used by callers of this method.
                 secondary_status: DiffHunkSecondaryStatus::None,
-                secondary_diff_base_byte_range: None,
             })
         })
     }
@@ -408,12 +409,12 @@ impl BufferDiffInner {
                         .start
                         .cmp(&old_hunk.buffer_range.start, new_snapshot)
                     {
-                        cmp::Ordering::Less => {
+                        Ordering::Less => {
                             start.get_or_insert(new_hunk.buffer_range.start);
                             end.replace(new_hunk.buffer_range.end);
                             new_cursor.next(new_snapshot);
                         }
-                        cmp::Ordering::Equal => {
+                        Ordering::Equal => {
                             if new_hunk != old_hunk {
                                 start.get_or_insert(new_hunk.buffer_range.start);
                                 if old_hunk
@@ -431,7 +432,7 @@ impl BufferDiffInner {
                             new_cursor.next(new_snapshot);
                             old_cursor.next(new_snapshot);
                         }
-                        cmp::Ordering::Greater => {
+                        Ordering::Greater => {
                             start.get_or_insert(old_hunk.buffer_range.start);
                             end.replace(old_hunk.buffer_range.end);
                             old_cursor.next(new_snapshot);
@@ -1059,6 +1060,7 @@ mod tests {
     use rand::{rngs::StdRng, Rng as _};
     use text::{Buffer, BufferId, Rope};
     use unindent::Unindent as _;
+    use util::test::marked_text_ranges;
 
     #[ctor::ctor]
     fn init_logger() {
@@ -1257,6 +1259,208 @@ mod tests {
         );
     }
 
+    #[gpui::test]
+    async fn test_stage_hunk(cx: &mut TestAppContext) {
+        struct Example {
+            name: &'static str,
+            head_text: String,
+            index_text: String,
+            buffer_marked_text: String,
+            final_index_text: String,
+        }
+
+        let table = [
+            Example {
+                name: "uncommitted hunk straddles end of unstaged hunk",
+                head_text: "
+                    one
+                    two
+                    three
+                    four
+                    five
+                "
+                .unindent(),
+                index_text: "
+                    one
+                    TWO_HUNDRED
+                    three
+                    FOUR_HUNDRED
+                    five
+                "
+                .unindent(),
+                buffer_marked_text: "
+                    ZERO
+                    one
+                    two
+                    «THREE_HUNDRED
+                    FOUR_HUNDRED»
+                    five
+                    SIX
+                "
+                .unindent(),
+                final_index_text: "
+                    one
+                    two
+                    THREE_HUNDRED
+                    FOUR_HUNDRED
+                    five
+                "
+                .unindent(),
+            },
+            Example {
+                name: "uncommitted hunk straddles start of unstaged hunk",
+                head_text: "
+                    one
+                    two
+                    three
+                    four
+                    five
+                "
+                .unindent(),
+                index_text: "
+                    one
+                    TWO_HUNDRED
+                    three
+                    FOUR_HUNDRED
+                    five
+                "
+                .unindent(),
+                buffer_marked_text: "
+                    ZERO
+                    one
+                    «TWO_HUNDRED
+                    THREE_HUNDRED»
+                    four
+                    five
+                    SIX
+                "
+                .unindent(),
+                final_index_text: "
+                    one
+                    TWO_HUNDRED
+                    THREE_HUNDRED
+                    four
+                    five
+                "
+                .unindent(),
+            },
+            Example {
+                name: "uncommitted hunk strictly contains unstaged hunks",
+                head_text: "
+                    one
+                    two
+                    three
+                    four
+                    five
+                    six
+                    seven
+                "
+                .unindent(),
+                index_text: "
+                    one
+                    TWO
+                    THREE
+                    FOUR
+                    FIVE
+                    SIX
+                    seven
+                "
+                .unindent(),
+                buffer_marked_text: "
+                    one
+                    TWO
+                    «THREE_HUNDRED
+                    FOUR
+                    FIVE_HUNDRED»
+                    SIX
+                    seven
+                "
+                .unindent(),
+                final_index_text: "
+                    one
+                    TWO
+                    THREE_HUNDRED
+                    FOUR
+                    FIVE_HUNDRED
+                    SIX
+                    seven
+                "
+                .unindent(),
+            },
+            Example {
+                name: "uncommitted deletion hunk",
+                head_text: "
+                    one
+                    two
+                    three
+                    four
+                    five
+                "
+                .unindent(),
+                index_text: "
+                    one
+                    two
+                    three
+                    four
+                    five
+                "
+                .unindent(),
+                buffer_marked_text: "
+                    one
+                    ˇfive
+                "
+                .unindent(),
+                final_index_text: "
+                    one
+                    five
+                "
+                .unindent(),
+            },
+        ];
+
+        for example in table {
+            let (buffer_text, ranges) = marked_text_ranges(&example.buffer_marked_text, false);
+            let buffer = Buffer::new(0, BufferId::new(1).unwrap(), buffer_text);
+            let uncommitted_diff =
+                BufferDiff::build_sync(buffer.clone(), example.head_text.clone(), cx);
+            let unstaged_diff =
+                BufferDiff::build_sync(buffer.clone(), example.index_text.clone(), cx);
+            let uncommitted_diff = BufferDiffSnapshot {
+                inner: uncommitted_diff,
+                secondary_diff: Some(Box::new(BufferDiffSnapshot {
+                    inner: unstaged_diff,
+                    is_single_insertion: false,
+                    secondary_diff: None,
+                })),
+                is_single_insertion: false,
+            };
+
+            let range = buffer.anchor_before(ranges[0].start)..buffer.anchor_before(ranges[0].end);
+
+            let new_index_text = cx
+                .update(|cx| {
+                    uncommitted_diff.new_secondary_text_for_stage_or_unstage(
+                        true,
+                        uncommitted_diff
+                            .hunks_intersecting_range(range, &buffer)
+                            .map(|hunk| {
+                                (hunk.buffer_range.clone(), hunk.diff_base_byte_range.clone())
+                            }),
+                        &buffer,
+                        cx,
+                    )
+                })
+                .unwrap()
+                .to_string();
+            pretty_assertions::assert_eq!(
+                new_index_text,
+                example.final_index_text,
+                "example: {}",
+                example.name
+            );
+        }
+    }
+
     #[gpui::test]
     async fn test_buffer_diff_compare(cx: &mut TestAppContext) {
         let base_text = "
@@ -1382,7 +1586,7 @@ mod tests {
     }
 
     #[gpui::test(iterations = 100)]
-    async fn test_secondary_edits_for_stage_unstage(cx: &mut TestAppContext, mut rng: StdRng) {
+    async fn test_staging_and_unstaging_hunks(cx: &mut TestAppContext, mut rng: StdRng) {
         fn gen_line(rng: &mut StdRng) -> String {
             if rng.gen_bool(0.2) {
                 "\n".to_owned()
@@ -1447,7 +1651,7 @@ mod tests {
 
         fn uncommitted_diff(
             working_copy: &language::BufferSnapshot,
-            index_text: &Entity<language::Buffer>,
+            index_text: &Rope,
             head_text: String,
             cx: &mut TestAppContext,
         ) -> BufferDiff {
@@ -1456,7 +1660,7 @@ mod tests {
                 buffer_id: working_copy.remote_id(),
                 inner: BufferDiff::build_sync(
                     working_copy.text.clone(),
-                    index_text.read_with(cx, |index_text, _| index_text.text()),
+                    index_text.to_string(),
                     cx,
                 ),
                 secondary_diff: None,
@@ -1487,17 +1691,11 @@ mod tests {
             )
         });
         let working_copy = working_copy.read_with(cx, |working_copy, _| working_copy.snapshot());
-        let index_text = cx.new(|cx| {
-            language::Buffer::local_normalized(
-                if rng.gen() {
-                    Rope::from(head_text.as_str())
-                } else {
-                    working_copy.as_rope().clone()
-                },
-                text::LineEnding::default(),
-                cx,
-            )
-        });
+        let mut index_text = if rng.gen() {
+            Rope::from(head_text.as_str())
+        } else {
+            working_copy.as_rope().clone()
+        };
 
         let mut diff = uncommitted_diff(&working_copy, &index_text, head_text.clone(), cx);
         let mut hunks = cx.update(|cx| {
@@ -1511,37 +1709,29 @@ mod tests {
         for _ in 0..operations {
             let i = rng.gen_range(0..hunks.len());
             let hunk = &mut hunks[i];
-            let hunk_fields = (
-                hunk.diff_base_byte_range.clone(),
-                hunk.secondary_diff_base_byte_range.clone(),
-                hunk.buffer_range.clone(),
-            );
-            let stage = match (
-                hunk.secondary_status,
-                hunk.secondary_diff_base_byte_range.clone(),
-            ) {
-                (DiffHunkSecondaryStatus::HasSecondaryHunk, Some(_)) => {
+            let stage = match hunk.secondary_status {
+                DiffHunkSecondaryStatus::HasSecondaryHunk => {
                     hunk.secondary_status = DiffHunkSecondaryStatus::None;
-                    hunk.secondary_diff_base_byte_range = None;
                     true
                 }
-                (DiffHunkSecondaryStatus::None, None) => {
+                DiffHunkSecondaryStatus::None => {
                     hunk.secondary_status = DiffHunkSecondaryStatus::HasSecondaryHunk;
-                    // We don't look at this, just notice whether it's Some or not.
-                    hunk.secondary_diff_base_byte_range = Some(17..17);
                     false
                 }
                 _ => unreachable!(),
             };
 
             let snapshot = cx.update(|cx| diff.snapshot(cx));
-            let edits = snapshot.secondary_edits_for_stage_or_unstage(
-                stage,
-                [hunk_fields].into_iter(),
-                &working_copy,
-            );
-            index_text.update(cx, |index_text, cx| {
-                index_text.edit(edits, None, cx);
+            index_text = cx.update(|cx| {
+                snapshot
+                    .new_secondary_text_for_stage_or_unstage(
+                        stage,
+                        [(hunk.buffer_range.clone(), hunk.diff_base_byte_range.clone())]
+                            .into_iter(),
+                        &working_copy,
+                        cx,
+                    )
+                    .unwrap()
             });
 
             diff = uncommitted_diff(&working_copy, &index_text, head_text.clone(), cx);
@@ -1550,6 +1740,7 @@ mod tests {
                     .collect::<Vec<_>>()
             });
             assert_eq!(hunks.len(), found_hunks.len());
+
             for (expected_hunk, found_hunk) in hunks.iter().zip(&found_hunks) {
                 assert_eq!(
                     expected_hunk.buffer_range.to_point(&working_copy),
@@ -1560,10 +1751,6 @@ mod tests {
                     found_hunk.diff_base_byte_range
                 );
                 assert_eq!(expected_hunk.secondary_status, found_hunk.secondary_status);
-                assert_eq!(
-                    expected_hunk.secondary_diff_base_byte_range.is_some(),
-                    found_hunk.secondary_diff_base_byte_range.is_some()
-                )
             }
             hunks = found_hunks;
         }

crates/collab/Cargo.toml

@@ -89,8 +89,11 @@ channel.workspace = true
 client = { workspace = true, features = ["test-support"] }
 collab_ui = { workspace = true, features = ["test-support"] }
 collections = { workspace = true, features = ["test-support"] }
+command_palette_hooks.workspace = true
 context_server.workspace = true
 ctor.workspace = true
+dap = { workspace = true, features = ["test-support"] }
+debugger_ui = { workspace = true, features = ["test-support"] }
 editor = { workspace = true, features = ["test-support"] }
 env_logger.workspace = true
 extension.workspace = true

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

@@ -469,3 +469,14 @@ CREATE TABLE IF NOT EXISTS processed_stripe_events (
 );
 
 CREATE INDEX "ix_processed_stripe_events_on_stripe_event_created_timestamp" ON processed_stripe_events (stripe_event_created_timestamp);
+
+CREATE TABLE IF NOT EXISTS "breakpoints" (
+    "id" INTEGER PRIMARY KEY AUTOINCREMENT,
+    "project_id" INTEGER NOT NULL REFERENCES projects (id) ON DELETE CASCADE,
+    "position" INTEGER NOT NULL,
+    "log_message" TEXT NULL,
+    "worktree_id" BIGINT NOT NULL,
+    "path" TEXT NOT NULL,
+    "kind" VARCHAR NOT NULL
+);
+CREATE INDEX "index_breakpoints_on_project_id" ON "breakpoints" ("project_id");

crates/collab/migrations/20241121185750_add_breakpoints.sql

@@ -0,0 +1,11 @@
+CREATE TABLE IF NOT EXISTS "breakpoints" (
+    "id" SERIAL PRIMARY KEY,
+    "project_id" INTEGER NOT NULL REFERENCES projects (id) ON DELETE CASCADE,
+    "position" INTEGER NOT NULL,
+    "log_message" TEXT NULL,
+    "worktree_id" BIGINT NOT NULL,
+    "path" TEXT NOT NULL,
+    "kind" VARCHAR NOT NULL
+);
+
+CREATE INDEX "index_breakpoints_on_project_id" ON "breakpoints" ("project_id");

crates/collab/src/db.rs

@@ -659,6 +659,7 @@ pub struct RejoinedProject {
     pub collaborators: Vec<ProjectCollaborator>,
     pub worktrees: Vec<RejoinedWorktree>,
     pub language_servers: Vec<proto::LanguageServer>,
+    pub breakpoints: HashMap<proto::ProjectPath, HashSet<proto::Breakpoint>>,
 }
 
 impl RejoinedProject {
@@ -681,6 +682,17 @@ impl RejoinedProject {
                 .map(|collaborator| collaborator.to_proto())
                 .collect(),
             language_servers: self.language_servers.clone(),
+            breakpoints: self
+                .breakpoints
+                .iter()
+                .map(
+                    |(project_path, breakpoints)| proto::SynchronizeBreakpoints {
+                        project_id: self.id.to_proto(),
+                        breakpoints: breakpoints.iter().cloned().collect(),
+                        project_path: Some(project_path.clone()),
+                    },
+                )
+                .collect(),
         }
     }
 }
@@ -727,6 +739,7 @@ pub struct Project {
     pub collaborators: Vec<ProjectCollaborator>,
     pub worktrees: BTreeMap<u64, Worktree>,
     pub language_servers: Vec<proto::LanguageServer>,
+    pub breakpoints: HashMap<proto::ProjectPath, HashSet<proto::Breakpoint>>,
 }
 
 pub struct ProjectCollaborator {

crates/collab/src/db/ids.rs

@@ -94,6 +94,9 @@ id_type!(RoomParticipantId);
 id_type!(ServerId);
 id_type!(SignupId);
 id_type!(UserId);
+id_type!(DebugClientId);
+id_type!(SessionId);
+id_type!(ThreadId);
 
 /// ChannelRole gives you permissions for both channels and calls.
 #[derive(

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

@@ -1,5 +1,5 @@
 use anyhow::Context as _;
-
+use collections::{HashMap, HashSet};
 use util::ResultExt;
 
 use super::*;
@@ -571,6 +571,60 @@ impl Database {
         .await
     }
 
+    pub async fn update_breakpoints(
+        &self,
+        connection_id: ConnectionId,
+        update: &proto::SynchronizeBreakpoints,
+    ) -> Result<TransactionGuard<HashSet<ConnectionId>>> {
+        let project_id = ProjectId::from_proto(update.project_id);
+        self.project_transaction(project_id, |tx| async move {
+            let project_path = update
+                .project_path
+                .as_ref()
+                .ok_or_else(|| anyhow!("invalid project path"))?;
+
+            // Ensure the update comes from the host.
+            let project = project::Entity::find_by_id(project_id)
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| anyhow!("no such project"))?;
+
+            // remove all existing breakpoints
+            breakpoints::Entity::delete_many()
+                .filter(breakpoints::Column::ProjectId.eq(project.id))
+                .exec(&*tx)
+                .await?;
+
+            if !update.breakpoints.is_empty() {
+                breakpoints::Entity::insert_many(update.breakpoints.iter().map(|breakpoint| {
+                    breakpoints::ActiveModel {
+                        id: ActiveValue::NotSet,
+                        project_id: ActiveValue::Set(project_id),
+                        worktree_id: ActiveValue::Set(project_path.worktree_id as i64),
+                        path: ActiveValue::Set(project_path.path.clone()),
+                        kind: match proto::BreakpointKind::from_i32(breakpoint.kind) {
+                            Some(proto::BreakpointKind::Log) => {
+                                ActiveValue::Set(breakpoints::BreakpointKind::Log)
+                            }
+                            Some(proto::BreakpointKind::Standard) => {
+                                ActiveValue::Set(breakpoints::BreakpointKind::Standard)
+                            }
+                            None => ActiveValue::Set(breakpoints::BreakpointKind::Standard),
+                        },
+                        log_message: ActiveValue::Set(breakpoint.message.clone()),
+                        position: ActiveValue::Set(breakpoint.cached_position as i32),
+                    }
+                }))
+                .exec_without_returning(&*tx)
+                .await?;
+            }
+
+            self.internal_project_connection_ids(project_id, connection_id, true, &tx)
+                .await
+        })
+        .await
+    }
+
     /// Updates the worktree settings for the given connection.
     pub async fn update_worktree_settings(
         &self,
@@ -852,6 +906,33 @@ impl Database {
             }
         }
 
+        let mut breakpoints: HashMap<proto::ProjectPath, HashSet<proto::Breakpoint>> =
+            HashMap::default();
+
+        let db_breakpoints = project.find_related(breakpoints::Entity).all(tx).await?;
+
+        for breakpoint in db_breakpoints.iter() {
+            let project_path = proto::ProjectPath {
+                worktree_id: breakpoint.worktree_id as u64,
+                path: breakpoint.path.clone(),
+            };
+
+            breakpoints
+                .entry(project_path)
+                .or_default()
+                .insert(proto::Breakpoint {
+                    position: None,
+                    cached_position: breakpoint.position as u32,
+                    kind: match breakpoint.kind {
+                        breakpoints::BreakpointKind::Standard => {
+                            proto::BreakpointKind::Standard.into()
+                        }
+                        breakpoints::BreakpointKind::Log => proto::BreakpointKind::Log.into(),
+                    },
+                    message: breakpoint.log_message.clone(),
+                });
+        }
+
         // Populate language servers.
         let language_servers = project
             .find_related(language_server::Entity)
@@ -879,6 +960,7 @@ impl Database {
                     worktree_id: None,
                 })
                 .collect(),
+            breakpoints,
         };
         Ok((project, replica_id as ReplicaId))
     }
@@ -1106,41 +1188,52 @@ impl Database {
         exclude_dev_server: bool,
     ) -> Result<TransactionGuard<HashSet<ConnectionId>>> {
         self.project_transaction(project_id, |tx| async move {
-            let project = project::Entity::find_by_id(project_id)
-                .one(&*tx)
-                .await?
-                .ok_or_else(|| anyhow!("no such project"))?;
-
-            let mut collaborators = project_collaborator::Entity::find()
-                .filter(project_collaborator::Column::ProjectId.eq(project_id))
-                .stream(&*tx)
-                .await?;
-
-            let mut connection_ids = HashSet::default();
-            if let Some(host_connection) = project.host_connection().log_err() {
-                if !exclude_dev_server {
-                    connection_ids.insert(host_connection);
-                }
-            }
-
-            while let Some(collaborator) = collaborators.next().await {
-                let collaborator = collaborator?;
-                connection_ids.insert(collaborator.connection());
-            }
-
-            if connection_ids.contains(&connection_id)
-                || Some(connection_id) == project.host_connection().ok()
-            {
-                Ok(connection_ids)
-            } else {
-                Err(anyhow!(
-                    "can only send project updates to a project you're in"
-                ))?
-            }
+            self.internal_project_connection_ids(project_id, connection_id, exclude_dev_server, &tx)
+                .await
         })
         .await
     }
 
+    async fn internal_project_connection_ids(
+        &self,
+        project_id: ProjectId,
+        connection_id: ConnectionId,
+        exclude_dev_server: bool,
+        tx: &DatabaseTransaction,
+    ) -> Result<HashSet<ConnectionId>> {
+        let project = project::Entity::find_by_id(project_id)
+            .one(tx)
+            .await?
+            .ok_or_else(|| anyhow!("no such project"))?;
+
+        let mut collaborators = project_collaborator::Entity::find()
+            .filter(project_collaborator::Column::ProjectId.eq(project_id))
+            .stream(tx)
+            .await?;
+
+        let mut connection_ids = HashSet::default();
+        if let Some(host_connection) = project.host_connection().log_err() {
+            if !exclude_dev_server {
+                connection_ids.insert(host_connection);
+            }
+        }
+
+        while let Some(collaborator) = collaborators.next().await {
+            let collaborator = collaborator?;
+            connection_ids.insert(collaborator.connection());
+        }
+
+        if connection_ids.contains(&connection_id)
+            || Some(connection_id) == project.host_connection().ok()
+        {
+            Ok(connection_ids)
+        } else {
+            Err(anyhow!(
+                "can only send project updates to a project you're in"
+            ))?
+        }
+    }
+
     async fn project_guest_connection_ids(
         &self,
         project_id: ProjectId,

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

@@ -765,6 +765,33 @@ impl Database {
             worktrees.push(worktree);
         }
 
+        let mut breakpoints: HashMap<proto::ProjectPath, HashSet<proto::Breakpoint>> =
+            HashMap::default();
+
+        let db_breakpoints = project.find_related(breakpoints::Entity).all(tx).await?;
+
+        for breakpoint in db_breakpoints.iter() {
+            let project_path = proto::ProjectPath {
+                worktree_id: breakpoint.worktree_id as u64,
+                path: breakpoint.path.clone(),
+            };
+
+            breakpoints
+                .entry(project_path)
+                .or_default()
+                .insert(proto::Breakpoint {
+                    position: None,
+                    cached_position: breakpoint.position as u32,
+                    kind: match breakpoint.kind {
+                        breakpoints::BreakpointKind::Standard => {
+                            proto::BreakpointKind::Standard.into()
+                        }
+                        breakpoints::BreakpointKind::Log => proto::BreakpointKind::Log.into(),
+                    },
+                    message: breakpoint.log_message.clone(),
+                });
+        }
+
         let language_servers = project
             .find_related(language_server::Entity)
             .all(tx)
@@ -834,6 +861,7 @@ impl Database {
             collaborators,
             worktrees,
             language_servers,
+            breakpoints,
         }))
     }
 

crates/collab/src/db/tables.rs

@@ -2,6 +2,7 @@ pub mod access_token;
 pub mod billing_customer;
 pub mod billing_preference;
 pub mod billing_subscription;
+pub mod breakpoints;
 pub mod buffer;
 pub mod buffer_operation;
 pub mod buffer_snapshot;

crates/collab/src/db/tables/breakpoints.rs

@@ -0,0 +1,47 @@
+use crate::db::ProjectId;
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "breakpoints")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    #[sea_orm(primary_key)]
+    pub project_id: ProjectId,
+    pub worktree_id: i64,
+    pub path: String,
+    pub kind: BreakpointKind,
+    pub log_message: Option<String>,
+    pub position: i32,
+}
+
+#[derive(
+    Copy, Clone, Debug, PartialEq, Eq, EnumIter, DeriveActiveEnum, Default, Hash, serde::Serialize,
+)]
+#[sea_orm(rs_type = "String", db_type = "String(StringLen::None)")]
+#[serde(rename_all = "snake_case")]
+pub enum BreakpointKind {
+    #[default]
+    #[sea_orm(string_value = "standard")]
+    Standard,
+    #[sea_orm(string_value = "log")]
+    Log,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::project::Entity",
+        from = "Column::ProjectId",
+        to = "super::project::Column::Id"
+    )]
+    Project,
+}
+
+impl Related<super::project::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Project.def()
+    }
+}
+
+impl ActiveModelBehavior for ActiveModel {}

crates/collab/src/db/tables/project.rs

@@ -49,6 +49,8 @@ pub enum Relation {
     Collaborators,
     #[sea_orm(has_many = "super::language_server::Entity")]
     LanguageServers,
+    #[sea_orm(has_many = "super::breakpoints::Entity")]
+    Breakpoints,
 }
 
 impl Related<super::user::Entity> for Entity {
@@ -81,4 +83,10 @@ impl Related<super::language_server::Entity> for Entity {
     }
 }
 
+impl Related<super::breakpoints::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Breakpoints.def()
+    }
+}
+
 impl ActiveModelBehavior for ActiveModel {}

crates/collab/src/llm.rs

@@ -256,6 +256,7 @@ async fn perform_completion(
             // so that users can use the new version, without having to update Zed.
             request.model = match model.as_str() {
                 "claude-3-5-sonnet" => anthropic::Model::Claude3_5Sonnet.id().to_string(),
+                "claude-3-7-sonnet" => anthropic::Model::Claude3_7Sonnet.id().to_string(),
                 "claude-3-opus" => anthropic::Model::Claude3Opus.id().to_string(),
                 "claude-3-haiku" => anthropic::Model::Claude3Haiku.id().to_string(),
                 "claude-3-sonnet" => anthropic::Model::Claude3Sonnet.id().to_string(),

crates/collab/src/rpc.rs

@@ -392,9 +392,13 @@ impl Server {
             .add_request_handler(forward_mutating_project_request::<proto::OpenContext>)
             .add_request_handler(forward_mutating_project_request::<proto::CreateContext>)
             .add_request_handler(forward_mutating_project_request::<proto::SynchronizeContexts>)
+            .add_request_handler(forward_mutating_project_request::<proto::Push>)
+            .add_request_handler(forward_mutating_project_request::<proto::Pull>)
+            .add_request_handler(forward_mutating_project_request::<proto::Fetch>)
             .add_request_handler(forward_mutating_project_request::<proto::Stage>)
             .add_request_handler(forward_mutating_project_request::<proto::Unstage>)
             .add_request_handler(forward_mutating_project_request::<proto::Commit>)
+            .add_request_handler(forward_read_only_project_request::<proto::GetRemotes>)
             .add_request_handler(forward_read_only_project_request::<proto::GitShow>)
             .add_request_handler(forward_read_only_project_request::<proto::GitReset>)
             .add_request_handler(forward_read_only_project_request::<proto::GitCheckoutFiles>)
@@ -423,7 +427,40 @@ impl Server {
                         app_state.config.openai_api_key.clone(),
                     )
                 }
-            });
+            })
+            .add_message_handler(update_breakpoints)
+            .add_message_handler(broadcast_project_message_from_host::<proto::SetActiveDebugLine>)
+            .add_message_handler(
+                broadcast_project_message_from_host::<proto::RemoveActiveDebugLine>,
+            )
+            .add_message_handler(broadcast_project_message_from_host::<proto::UpdateDebugAdapter>)
+            .add_message_handler(
+                broadcast_project_message_from_host::<proto::SetDebugClientCapabilities>,
+            )
+            .add_message_handler(broadcast_project_message_from_host::<proto::ShutdownDebugClient>)
+            .add_request_handler(forward_mutating_project_request::<proto::DapNextRequest>)
+            .add_request_handler(forward_mutating_project_request::<proto::DapStepInRequest>)
+            .add_request_handler(forward_mutating_project_request::<proto::DapStepOutRequest>)
+            .add_request_handler(forward_mutating_project_request::<proto::DapStepBackRequest>)
+            .add_request_handler(forward_mutating_project_request::<proto::DapContinueRequest>)
+            .add_request_handler(forward_mutating_project_request::<proto::DapPauseRequest>)
+            .add_request_handler(forward_mutating_project_request::<proto::DapDisconnectRequest>)
+            .add_request_handler(
+                forward_mutating_project_request::<proto::DapTerminateThreadsRequest>,
+            )
+            .add_request_handler(forward_mutating_project_request::<proto::DapRestartRequest>)
+            .add_request_handler(forward_mutating_project_request::<proto::DapTerminateRequest>)
+            .add_message_handler(broadcast_project_message_from_host::<proto::UpdateThreadStatus>)
+            .add_request_handler(forward_mutating_project_request::<proto::VariablesRequest>)
+            .add_message_handler(
+                broadcast_project_message_from_host::<proto::DapRestartStackFrameRequest>,
+            )
+            .add_message_handler(
+                broadcast_project_message_from_host::<proto::ToggleIgnoreBreakpoints>,
+            )
+            .add_message_handler(
+                broadcast_project_message_from_host::<proto::IgnoreBreakpointState>,
+            );
 
         Arc::new(server)
     }
@@ -1863,6 +1900,18 @@ fn join_project_internal(
             .trace_err();
     }
 
+    let breakpoints = project
+        .breakpoints
+        .iter()
+        .map(
+            |(project_path, breakpoint_set)| proto::SynchronizeBreakpoints {
+                project_id: project.id.0 as u64,
+                breakpoints: breakpoint_set.iter().map(|bp| bp.clone()).collect(),
+                project_path: Some(project_path.clone()),
+            },
+        )
+        .collect();
+
     // First, we send the metadata associated with each worktree.
     response.send(proto::JoinProjectResponse {
         project_id: project.id.0 as u64,
@@ -1871,6 +1920,7 @@ fn join_project_internal(
         collaborators: collaborators.clone(),
         language_servers: project.language_servers.clone(),
         role: project.role.into(),
+        breakpoints,
     })?;
 
     for (worktree_id, worktree) in mem::take(&mut project.worktrees) {
@@ -2057,7 +2107,7 @@ async fn update_worktree_settings(
     Ok(())
 }
 
-/// Notify other participants that a  language server has started.
+/// Notify other participants that a language server has started.
 async fn start_language_server(
     request: proto::StartLanguageServer,
     session: Session,
@@ -2103,6 +2153,29 @@ async fn update_language_server(
     Ok(())
 }
 
+/// Notify other participants that breakpoints have changed.
+async fn update_breakpoints(
+    request: proto::SynchronizeBreakpoints,
+    session: Session,
+) -> Result<()> {
+    let guest_connection_ids = session
+        .db()
+        .await
+        .update_breakpoints(session.connection_id, &request)
+        .await?;
+
+    broadcast(
+        Some(session.connection_id),
+        guest_connection_ids.iter().copied(),
+        |connection_id| {
+            session
+                .peer
+                .forward_send(session.connection_id, connection_id, request.clone())
+        },
+    );
+    Ok(())
+}
+
 /// forward a project request to the host. These requests should be read only
 /// as guests are allowed to send them.
 async fn forward_read_only_project_request<T>(

crates/collab/src/tests.rs

@@ -11,6 +11,7 @@ mod channel_buffer_tests;
 mod channel_guest_tests;
 mod channel_message_tests;
 mod channel_tests;
+mod debug_panel_tests;
 mod editor_tests;
 mod following_tests;
 mod integration_tests;

crates/collab/src/tests/editor_tests.rs

@@ -22,7 +22,7 @@ use language::{
 };
 use project::{
     project_settings::{InlineBlameSettings, ProjectSettings},
-    SERVER_PROGRESS_THROTTLE_TIMEOUT,
+    ProjectPath, SERVER_PROGRESS_THROTTLE_TIMEOUT,
 };
 use recent_projects::disconnected_overlay::DisconnectedOverlay;
 use rpc::RECEIVE_TIMEOUT;
@@ -1591,6 +1591,8 @@ async fn test_mutual_editor_inlay_hint_cache_update(
         .await
         .unwrap();
 
+    executor.run_until_parked();
+
     // Client B joins the project
     let project_b = client_b.join_remote_project(project_id, cx_b).await;
     active_call_b
@@ -2394,6 +2396,202 @@ fn main() { let foo = other::foo(); }"};
     );
 }
 
+#[gpui::test]
+async fn test_add_breakpoints(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
+    let executor = cx_a.executor();
+    let mut server = TestServer::start(executor.clone()).await;
+    let client_a = server.create_client(cx_a, "user_a").await;
+    let client_b = server.create_client(cx_b, "user_b").await;
+    server
+        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
+        .await;
+    let active_call_a = cx_a.read(ActiveCall::global);
+    let active_call_b = cx_b.read(ActiveCall::global);
+    cx_a.update(editor::init);
+    cx_b.update(editor::init);
+    client_a
+        .fs()
+        .insert_tree(
+            "/a",
+            json!({
+                "test.txt": "one\ntwo\nthree\nfour\nfive",
+            }),
+        )
+        .await;
+    let (project_a, worktree_id) = client_a.build_local_project("/a", cx_a).await;
+    let project_path = ProjectPath {
+        worktree_id,
+        path: Arc::from(Path::new(&"test.txt")),
+    };
+    active_call_a
+        .update(cx_a, |call, cx| call.set_location(Some(&project_a), cx))
+        .await
+        .unwrap();
+    let project_id = active_call_a
+        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
+        .await
+        .unwrap();
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
+    active_call_b
+        .update(cx_b, |call, cx| call.set_location(Some(&project_b), cx))
+        .await
+        .unwrap();
+    let (workspace_a, cx_a) = client_a.build_workspace(&project_a, cx_a);
+    let (workspace_b, cx_b) = client_b.build_workspace(&project_b, cx_b);
+
+    // Client A opens an editor.
+    let editor_a = workspace_a
+        .update_in(cx_a, |workspace, window, cx| {
+            workspace.open_path(project_path.clone(), None, true, window, cx)
+        })
+        .await
+        .unwrap()
+        .downcast::<Editor>()
+        .unwrap();
+
+    // Client B opens same editor as A.
+    let editor_b = workspace_b
+        .update_in(cx_b, |workspace, window, cx| {
+            workspace.open_path(project_path.clone(), None, true, window, cx)
+        })
+        .await
+        .unwrap()
+        .downcast::<Editor>()
+        .unwrap();
+
+    cx_a.run_until_parked();
+    cx_b.run_until_parked();
+
+    // Client A adds breakpoint on line (1)
+    editor_a.update_in(cx_a, |editor, window, cx| {
+        editor.toggle_breakpoint(&editor::actions::ToggleBreakpoint, window, cx);
+    });
+
+    cx_a.run_until_parked();
+    cx_b.run_until_parked();
+
+    let breakpoints_a = editor_a.update(cx_a, |editor, cx| {
+        editor
+            .breakpoint_store()
+            .clone()
+            .unwrap()
+            .read(cx)
+            .breakpoints()
+            .clone()
+    });
+    let breakpoints_b = editor_b.update(cx_b, |editor, cx| {
+        editor
+            .breakpoint_store()
+            .clone()
+            .unwrap()
+            .read(cx)
+            .breakpoints()
+            .clone()
+    });
+
+    assert_eq!(1, breakpoints_a.len());
+    assert_eq!(1, breakpoints_a.get(&project_path).unwrap().len());
+    assert_eq!(breakpoints_a, breakpoints_b);
+
+    // Client B adds breakpoint on line(2)
+    editor_b.update_in(cx_b, |editor, window, cx| {
+        editor.move_down(&editor::actions::MoveDown, window, cx);
+        editor.move_down(&editor::actions::MoveDown, window, cx);
+        editor.toggle_breakpoint(&editor::actions::ToggleBreakpoint, window, cx);
+    });
+
+    cx_a.run_until_parked();
+    cx_b.run_until_parked();
+
+    let breakpoints_a = editor_a.update(cx_a, |editor, cx| {
+        editor
+            .breakpoint_store()
+            .clone()
+            .unwrap()
+            .read(cx)
+            .breakpoints()
+            .clone()
+    });
+    let breakpoints_b = editor_b.update(cx_b, |editor, cx| {
+        editor
+            .breakpoint_store()
+            .clone()
+            .unwrap()
+            .read(cx)
+            .breakpoints()
+            .clone()
+    });
+
+    assert_eq!(1, breakpoints_a.len());
+    assert_eq!(breakpoints_a, breakpoints_b);
+    assert_eq!(2, breakpoints_a.get(&project_path).unwrap().len());
+
+    // Client A removes last added breakpoint from client B
+    editor_a.update_in(cx_a, |editor, window, cx| {
+        editor.move_down(&editor::actions::MoveDown, window, cx);
+        editor.move_down(&editor::actions::MoveDown, window, cx);
+        editor.toggle_breakpoint(&editor::actions::ToggleBreakpoint, window, cx);
+    });
+
+    cx_a.run_until_parked();
+    cx_b.run_until_parked();
+
+    let breakpoints_a = editor_a.update(cx_a, |editor, cx| {
+        editor
+            .breakpoint_store()
+            .clone()
+            .unwrap()
+            .read(cx)
+            .breakpoints()
+            .clone()
+    });
+    let breakpoints_b = editor_b.update(cx_b, |editor, cx| {
+        editor
+            .breakpoint_store()
+            .clone()
+            .unwrap()
+            .read(cx)
+            .breakpoints()
+            .clone()
+    });
+
+    assert_eq!(1, breakpoints_a.len());
+    assert_eq!(breakpoints_a, breakpoints_b);
+    assert_eq!(1, breakpoints_a.get(&project_path).unwrap().len());
+
+    // Client B removes first added breakpoint by client A
+    editor_b.update_in(cx_b, |editor, window, cx| {
+        editor.move_up(&editor::actions::MoveUp, window, cx);
+        editor.move_up(&editor::actions::MoveUp, window, cx);
+        editor.toggle_breakpoint(&editor::actions::ToggleBreakpoint, window, cx);
+    });
+
+    cx_a.run_until_parked();
+    cx_b.run_until_parked();
+
+    let breakpoints_a = editor_a.update(cx_a, |editor, cx| {
+        editor
+            .breakpoint_store()
+            .clone()
+            .unwrap()
+            .read(cx)
+            .breakpoints()
+            .clone()
+    });
+    let breakpoints_b = editor_b.update(cx_b, |editor, cx| {
+        editor
+            .breakpoint_store()
+            .clone()
+            .unwrap()
+            .read(cx)
+            .breakpoints()
+            .clone()
+    });
+
+    assert_eq!(0, breakpoints_a.len());
+    assert_eq!(breakpoints_a, breakpoints_b);
+}
+
 #[track_caller]
 fn tab_undo_assert(
     cx_a: &mut EditorTestContext,

crates/copilot/Cargo.toml

@@ -38,6 +38,7 @@ gpui.workspace = true
 http_client.workspace = true
 inline_completion.workspace = true
 language.workspace = true
+log.workspace = true
 lsp.workspace = true
 menu.workspace = true
 node_runtime.workspace = true
@@ -62,7 +63,9 @@ async-std = { version = "1.12.0", features = ["unstable"] }
 client = { workspace = true, features = ["test-support"] }
 clock = { workspace = true, features = ["test-support"] }
 collections = { workspace = true, features = ["test-support"] }
+ctor.workspace = true
 editor = { workspace = true, features = ["test-support"] }
+env_logger.workspace = true
 fs = { workspace = true, features = ["test-support"] }
 gpui = { workspace = true, features = ["test-support"] }
 http_client = { workspace = true, features = ["test-support"] }

crates/copilot/src/copilot.rs

@@ -16,6 +16,7 @@ use gpui::{
 };
 use http_client::github::get_release_by_tag_name;
 use http_client::HttpClient;
+use language::language_settings::CopilotSettings;
 use language::{
     language_settings::{all_language_settings, language_settings, EditPredictionProvider},
     point_from_lsp, point_to_lsp, Anchor, Bias, Buffer, BufferSnapshot, Language, PointUtf16,
@@ -367,13 +368,13 @@ impl Copilot {
         let server_id = self.server_id;
         let http = self.http.clone();
         let node_runtime = self.node_runtime.clone();
-        if all_language_settings(None, cx).edit_predictions.provider
-            == EditPredictionProvider::Copilot
-        {
+        let language_settings = all_language_settings(None, cx);
+        if language_settings.edit_predictions.provider == EditPredictionProvider::Copilot {
             if matches!(self.server, CopilotServer::Disabled) {
+                let env = self.build_env(&language_settings.edit_predictions.copilot);
                 let start_task = cx
                     .spawn(move |this, cx| {
-                        Self::start_language_server(server_id, http, node_runtime, this, cx)
+                        Self::start_language_server(server_id, http, node_runtime, env, this, cx)
                     })
                     .shared();
                 self.server = CopilotServer::Starting { task: start_task };
@@ -385,6 +386,30 @@ impl Copilot {
         }
     }
 
+    fn build_env(&self, copilot_settings: &CopilotSettings) -> Option<HashMap<String, String>> {
+        let proxy_url = copilot_settings.proxy.clone()?;
+        let no_verify = copilot_settings.proxy_no_verify;
+        let http_or_https_proxy = if proxy_url.starts_with("http:") {
+            "HTTP_PROXY"
+        } else if proxy_url.starts_with("https:") {
+            "HTTPS_PROXY"
+        } else {
+            log::error!(
+                "Unsupported protocol scheme for language server proxy (must be http or https)"
+            );
+            return None;
+        };
+
+        let mut env = HashMap::default();
+        env.insert(http_or_https_proxy.to_string(), proxy_url);
+
+        if let Some(true) = no_verify {
+            env.insert("NODE_TLS_REJECT_UNAUTHORIZED".to_string(), "0".to_string());
+        };
+
+        Some(env)
+    }
+
     #[cfg(any(test, feature = "test-support"))]
     pub fn fake(cx: &mut gpui::TestAppContext) -> (Entity<Self>, lsp::FakeLanguageServer) {
         use lsp::FakeLanguageServer;
@@ -422,6 +447,7 @@ impl Copilot {
         new_server_id: LanguageServerId,
         http: Arc<dyn HttpClient>,
         node_runtime: NodeRuntime,
+        env: Option<HashMap<String, String>>,
         this: WeakEntity<Self>,
         mut cx: AsyncApp,
     ) {
@@ -432,8 +458,7 @@ impl Copilot {
             let binary = LanguageServerBinary {
                 path: node_path,
                 arguments,
-                // TODO: We could set HTTP_PROXY etc here and fix the copilot issue.
-                env: None,
+                env,
             };
 
             let root_path = if cfg!(target_os = "windows") {
@@ -611,6 +636,8 @@ impl Copilot {
     }
 
     pub fn reinstall(&mut self, cx: &mut Context<Self>) -> Task<()> {
+        let language_settings = all_language_settings(None, cx);
+        let env = self.build_env(&language_settings.edit_predictions.copilot);
         let start_task = cx
             .spawn({
                 let http = self.http.clone();
@@ -618,7 +645,7 @@ impl Copilot {
                 let server_id = self.server_id;
                 move |this, cx| async move {
                     clear_copilot_dir().await;
-                    Self::start_language_server(server_id, http, node_runtime, this, cx).await
+                    Self::start_language_server(server_id, http, node_runtime, env, this, cx).await
                 }
             })
             .shared();
@@ -1279,3 +1306,11 @@ mod tests {
         }
     }
 }
+
+#[cfg(test)]
+#[ctor::ctor]
+fn init_logger() {
+    if std::env::var("RUST_LOG").is_ok() {
+        env_logger::init();
+    }
+}

crates/dap/Cargo.toml

@@ -0,0 +1,54 @@
+[package]
+name = "dap"
+version = "0.1.0"
+edition.workspace = true
+publish.workspace = true
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[features]
+test-support = [
+    "gpui/test-support",
+    "util/test-support",
+    "task/test-support",
+    "async-pipe",
+    "settings/test-support",
+]
+
+[dependencies]
+anyhow.workspace = true
+async-compression.workspace = true
+async-pipe = { workspace = true, optional = true }
+async-tar.workspace = true
+async-trait.workspace = true
+client.workspace = true
+collections.workspace = true
+dap-types = { git = "https://github.com/zed-industries/dap-types", rev = "bf5632dc19f806e8a435c9f04a4bfe7322badea2" }
+fs.workspace = true
+futures.workspace = true
+gpui.workspace = true
+http_client.workspace = true
+language.workspace = true
+log.workspace = true
+node_runtime.workspace = true
+parking_lot.workspace = true
+paths.workspace = true
+schemars.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+settings.workspace = true
+smallvec.workspace = true
+smol.workspace = true
+sysinfo.workspace = true
+task.workspace = true
+util.workspace = true
+
+[dev-dependencies]
+async-pipe.workspace = true
+env_logger.workspace = true
+gpui = { workspace = true, features = ["test-support"] }
+settings = { workspace = true, features = ["test-support"] }
+task = { workspace = true, features = ["test-support"] }
+util = { workspace = true, features = ["test-support"] }

crates/dap/LICENSE-GPL

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

crates/dap/docs/breakpoints.md

@@ -0,0 +1,9 @@
+# Overview
+
+The active `Project` is responsible for maintain opened and closed breakpoints
+as well as serializing breakpoints to save. At a high level project serializes
+the positions of breakpoints that don't belong to any active buffers and handles
+converting breakpoints from serializing to active whenever a buffer is opened/closed.
+
+`Project` also handles sending all relevant breakpoint information to debug adapter's
+during debugging or when starting a debugger.

crates/dap/src/adapters.rs

@@ -0,0 +1,391 @@
+use ::fs::Fs;
+use anyhow::{anyhow, Context as _, Ok, Result};
+use async_compression::futures::bufread::GzipDecoder;
+use async_tar::Archive;
+use async_trait::async_trait;
+use futures::io::BufReader;
+use gpui::{AsyncApp, SharedString};
+pub use http_client::{github::latest_github_release, HttpClient};
+use language::LanguageToolchainStore;
+use node_runtime::NodeRuntime;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use settings::WorktreeId;
+use smol::{self, fs::File, lock::Mutex};
+use std::{
+    collections::{HashMap, HashSet},
+    ffi::{OsStr, OsString},
+    fmt::Debug,
+    net::Ipv4Addr,
+    ops::Deref,
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+use sysinfo::{Pid, Process};
+use task::DebugAdapterConfig;
+use util::ResultExt;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum DapStatus {
+    None,
+    CheckingForUpdate,
+    Downloading,
+    Failed { error: String },
+}
+
+#[async_trait(?Send)]
+pub trait DapDelegate {
+    fn worktree_id(&self) -> WorktreeId;
+    fn http_client(&self) -> Arc<dyn HttpClient>;
+    fn node_runtime(&self) -> NodeRuntime;
+    fn toolchain_store(&self) -> Arc<dyn LanguageToolchainStore>;
+    fn fs(&self) -> Arc<dyn Fs>;
+    fn updated_adapters(&self) -> Arc<Mutex<HashSet<DebugAdapterName>>>;
+    fn update_status(&self, dap_name: DebugAdapterName, status: DapStatus);
+    fn which(&self, command: &OsStr) -> Option<PathBuf>;
+    async fn shell_env(&self) -> collections::HashMap<String, String>;
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Deserialize, Serialize)]
+pub struct DebugAdapterName(pub Arc<str>);
+
+impl Deref for DebugAdapterName {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl AsRef<str> for DebugAdapterName {
+    fn as_ref(&self) -> &str {
+        &self.0
+    }
+}
+
+impl AsRef<Path> for DebugAdapterName {
+    fn as_ref(&self) -> &Path {
+        Path::new(&*self.0)
+    }
+}
+
+impl std::fmt::Display for DebugAdapterName {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(&self.0, f)
+    }
+}
+
+impl From<DebugAdapterName> for SharedString {
+    fn from(name: DebugAdapterName) -> Self {
+        SharedString::from(name.0)
+    }
+}
+
+impl<'a> From<&'a str> for DebugAdapterName {
+    fn from(str: &'a str) -> DebugAdapterName {
+        DebugAdapterName(str.to_string().into())
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct TcpArguments {
+    pub host: Ipv4Addr,
+    pub port: u16,
+    pub timeout: Option<u64>,
+}
+#[derive(Debug, Clone)]
+pub struct DebugAdapterBinary {
+    pub command: String,
+    pub arguments: Option<Vec<OsString>>,
+    pub envs: Option<HashMap<String, String>>,
+    pub cwd: Option<PathBuf>,
+    pub connection: Option<TcpArguments>,
+}
+
+pub struct AdapterVersion {
+    pub tag_name: String,
+    pub url: String,
+}
+
+pub enum DownloadedFileType {
+    Vsix,
+    GzipTar,
+    Zip,
+}
+
+pub struct GithubRepo {
+    pub repo_name: String,
+    pub repo_owner: String,
+}
+
+pub async fn download_adapter_from_github(
+    adapter_name: DebugAdapterName,
+    github_version: AdapterVersion,
+    file_type: DownloadedFileType,
+    delegate: &dyn DapDelegate,
+) -> Result<PathBuf> {
+    let adapter_path = paths::debug_adapters_dir().join(&adapter_name);
+    let version_path = adapter_path.join(format!("{}_{}", adapter_name, github_version.tag_name));
+    let fs = delegate.fs();
+
+    if version_path.exists() {
+        return Ok(version_path);
+    }
+
+    if !adapter_path.exists() {
+        fs.create_dir(&adapter_path.as_path())
+            .await
+            .context("Failed creating adapter path")?;
+    }
+
+    log::debug!(
+        "Downloading adapter {} from {}",
+        adapter_name,
+        &github_version.url,
+    );
+
+    let mut response = delegate
+        .http_client()
+        .get(&github_version.url, Default::default(), true)
+        .await
+        .context("Error downloading release")?;
+    if !response.status().is_success() {
+        Err(anyhow!(
+            "download failed with status {}",
+            response.status().to_string()
+        ))?;
+    }
+
+    match file_type {
+        DownloadedFileType::GzipTar => {
+            let decompressed_bytes = GzipDecoder::new(BufReader::new(response.body_mut()));
+            let archive = Archive::new(decompressed_bytes);
+            archive.unpack(&version_path).await?;
+        }
+        DownloadedFileType::Zip | DownloadedFileType::Vsix => {
+            let zip_path = version_path.with_extension("zip");
+
+            let mut file = File::create(&zip_path).await?;
+            futures::io::copy(response.body_mut(), &mut file).await?;
+
+            // we cannot check the status as some adapter include files with names that trigger `Illegal byte sequence`
+            util::command::new_smol_command("unzip")
+                .arg(&zip_path)
+                .arg("-d")
+                .arg(&version_path)
+                .output()
+                .await?;
+
+            util::fs::remove_matching(&adapter_path, |entry| {
+                entry
+                    .file_name()
+                    .is_some_and(|file| file.to_string_lossy().ends_with(".zip"))
+            })
+            .await;
+        }
+    }
+
+    // remove older versions
+    util::fs::remove_matching(&adapter_path, |entry| {
+        entry.to_string_lossy() != version_path.to_string_lossy()
+    })
+    .await;
+
+    Ok(version_path)
+}
+
+pub 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.zipball_url,
+    })
+}
+
+#[async_trait(?Send)]
+pub trait DebugAdapter: 'static + Send + Sync {
+    fn name(&self) -> DebugAdapterName;
+
+    async fn get_binary(
+        &self,
+        delegate: &dyn DapDelegate,
+        config: &DebugAdapterConfig,
+        user_installed_path: Option<PathBuf>,
+        cx: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary> {
+        if delegate
+            .updated_adapters()
+            .lock()
+            .await
+            .contains(&self.name())
+        {
+            log::info!("Using cached debug adapter binary {}", self.name());
+
+            if let Some(binary) = self
+                .get_installed_binary(delegate, &config, user_installed_path.clone(), cx)
+                .await
+                .log_err()
+            {
+                return Ok(binary);
+            }
+
+            log::info!(
+                "Cached binary {} is corrupt falling back to install",
+                self.name()
+            );
+        }
+
+        log::info!("Getting latest version of debug adapter {}", self.name());
+        delegate.update_status(self.name(), DapStatus::CheckingForUpdate);
+        if let Some(version) = self.fetch_latest_adapter_version(delegate).await.log_err() {
+            log::info!(
+                "Installiing latest version of debug adapter {}",
+                self.name()
+            );
+            delegate.update_status(self.name(), DapStatus::Downloading);
+            self.install_binary(version, delegate).await?;
+
+            delegate
+                .updated_adapters()
+                .lock_arc()
+                .await
+                .insert(self.name());
+        }
+
+        self.get_installed_binary(delegate, &config, user_installed_path, cx)
+            .await
+    }
+
+    async fn fetch_latest_adapter_version(
+        &self,
+        delegate: &dyn DapDelegate,
+    ) -> Result<AdapterVersion>;
+
+    /// Installs the binary for the debug adapter.
+    /// This method is called when the adapter binary is not found or needs to be updated.
+    /// It should download and install the necessary files for the debug adapter to function.
+    async fn install_binary(
+        &self,
+        version: AdapterVersion,
+        delegate: &dyn DapDelegate,
+    ) -> Result<()>;
+
+    async fn get_installed_binary(
+        &self,
+        delegate: &dyn DapDelegate,
+        config: &DebugAdapterConfig,
+        user_installed_path: Option<PathBuf>,
+        cx: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary>;
+
+    /// Should return base configuration to make the debug adapter work
+    fn request_args(&self, config: &DebugAdapterConfig) -> Value;
+
+    /// Filters out the processes that the adapter can attach to for debugging
+    fn attach_processes<'a>(
+        &self,
+        _: &'a HashMap<Pid, Process>,
+    ) -> Option<Vec<(&'a Pid, &'a Process)>> {
+        None
+    }
+}
+
+#[cfg(any(test, feature = "test-support"))]
+pub struct FakeAdapter {}
+
+#[cfg(any(test, feature = "test-support"))]
+impl FakeAdapter {
+    const ADAPTER_NAME: &'static str = "fake-adapter";
+
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[cfg(any(test, feature = "test-support"))]
+#[async_trait(?Send)]
+impl DebugAdapter for FakeAdapter {
+    fn name(&self) -> DebugAdapterName {
+        DebugAdapterName(Self::ADAPTER_NAME.into())
+    }
+
+    async fn get_binary(
+        &self,
+        _: &dyn DapDelegate,
+        _: &DebugAdapterConfig,
+        _: Option<PathBuf>,
+        _: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary> {
+        Ok(DebugAdapterBinary {
+            command: "command".into(),
+            arguments: None,
+            connection: None,
+            envs: None,
+            cwd: None,
+        })
+    }
+
+    async fn fetch_latest_adapter_version(
+        &self,
+        _delegate: &dyn DapDelegate,
+    ) -> Result<AdapterVersion> {
+        unimplemented!("fetch latest adapter version");
+    }
+
+    async fn install_binary(
+        &self,
+        _version: AdapterVersion,
+        _delegate: &dyn DapDelegate,
+    ) -> Result<()> {
+        unimplemented!("install binary");
+    }
+
+    async fn get_installed_binary(
+        &self,
+        _: &dyn DapDelegate,
+        _: &DebugAdapterConfig,
+        _: Option<PathBuf>,
+        _: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary> {
+        unimplemented!("get installed binary");
+    }
+
+    fn request_args(&self, config: &DebugAdapterConfig) -> Value {
+        use serde_json::json;
+        use task::DebugRequestType;
+
+        json!({
+            "request": match config.request {
+                DebugRequestType::Launch => "launch",
+                DebugRequestType::Attach(_) => "attach",
+            },
+            "process_id": if let DebugRequestType::Attach(attach_config) = &config.request {
+                attach_config.process_id
+            } else {
+                None
+            },
+        })
+    }
+
+    fn attach_processes<'a>(
+        &self,
+        processes: &'a HashMap<Pid, Process>,
+    ) -> Option<Vec<(&'a Pid, &'a Process)>> {
+        Some(
+            processes
+                .iter()
+                .filter(|(pid, _)| pid.as_u32() == std::process::id())
+                .collect::<Vec<_>>(),
+        )
+    }
+}

crates/dap/src/client.rs

@@ -0,0 +1,485 @@
+use crate::{
+    adapters::DebugAdapterBinary,
+    transport::{IoKind, LogKind, TransportDelegate},
+};
+use anyhow::{anyhow, Result};
+use dap_types::{
+    messages::{Message, Response},
+    requests::Request,
+};
+use futures::{channel::oneshot, select, FutureExt as _};
+use gpui::{App, AsyncApp, BackgroundExecutor};
+use smol::channel::{Receiver, Sender};
+use std::{
+    hash::Hash,
+    sync::atomic::{AtomicU64, Ordering},
+    time::Duration,
+};
+
+#[cfg(any(test, feature = "test-support"))]
+const DAP_REQUEST_TIMEOUT: Duration = Duration::from_secs(2);
+
+#[cfg(not(any(test, feature = "test-support")))]
+const DAP_REQUEST_TIMEOUT: Duration = Duration::from_secs(12);
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[repr(transparent)]
+pub struct SessionId(pub u32);
+
+impl SessionId {
+    pub fn from_proto(client_id: u64) -> Self {
+        Self(client_id as u32)
+    }
+
+    pub fn to_proto(&self) -> u64 {
+        self.0 as u64
+    }
+}
+
+/// Represents a connection to the debug adapter process, either via stdout/stdin or a socket.
+pub struct DebugAdapterClient {
+    id: SessionId,
+    sequence_count: AtomicU64,
+    binary: DebugAdapterBinary,
+    executor: BackgroundExecutor,
+    transport_delegate: TransportDelegate,
+}
+
+pub type DapMessageHandler = Box<dyn FnMut(Message, &mut App) + 'static + Send + Sync>;
+
+impl DebugAdapterClient {
+    pub async fn start(
+        id: SessionId,
+        binary: DebugAdapterBinary,
+        message_handler: DapMessageHandler,
+        cx: AsyncApp,
+    ) -> Result<Self> {
+        let ((server_rx, server_tx), transport_delegate) =
+            TransportDelegate::start(&binary, cx.clone()).await?;
+        let this = Self {
+            id,
+            binary,
+            transport_delegate,
+            sequence_count: AtomicU64::new(1),
+            executor: cx.background_executor().clone(),
+        };
+        log::info!("Successfully connected to debug adapter");
+
+        let client_id = this.id;
+
+        // start handling events/reverse requests
+        cx.update(|cx| {
+            cx.spawn({
+                let server_tx = server_tx.clone();
+                |mut cx| async move {
+                    Self::handle_receive_messages(
+                        client_id,
+                        server_rx,
+                        server_tx,
+                        message_handler,
+                        &mut cx,
+                    )
+                    .await
+                }
+            })
+            .detach_and_log_err(cx);
+
+            this
+        })
+    }
+
+    pub async fn reconnect(
+        &self,
+        session_id: SessionId,
+        binary: DebugAdapterBinary,
+        message_handler: DapMessageHandler,
+        cx: AsyncApp,
+    ) -> Result<Self> {
+        let binary = match self.transport_delegate.transport() {
+            crate::transport::Transport::Tcp(tcp_transport) => DebugAdapterBinary {
+                command: binary.command,
+                arguments: binary.arguments,
+                envs: binary.envs,
+                cwd: binary.cwd,
+                connection: Some(crate::adapters::TcpArguments {
+                    host: tcp_transport.host,
+                    port: tcp_transport.port,
+                    timeout: Some(tcp_transport.timeout),
+                }),
+            },
+            _ => self.binary.clone(),
+        };
+
+        Self::start(session_id, binary, message_handler, cx).await
+    }
+
+    async fn handle_receive_messages(
+        client_id: SessionId,
+        server_rx: Receiver<Message>,
+        client_tx: Sender<Message>,
+        mut message_handler: DapMessageHandler,
+        cx: &mut AsyncApp,
+    ) -> Result<()> {
+        let result = loop {
+            let message = match server_rx.recv().await {
+                Ok(message) => message,
+                Err(e) => break Err(e.into()),
+            };
+
+            if let Err(e) = match message {
+                Message::Event(ev) => {
+                    log::debug!("Client {} received event `{}`", client_id.0, &ev);
+
+                    cx.update(|cx| message_handler(Message::Event(ev), cx))
+                }
+                Message::Request(req) => cx.update(|cx| message_handler(Message::Request(req), cx)),
+                Message::Response(response) => {
+                    log::debug!("Received response after request timeout: {:#?}", response);
+
+                    Ok(())
+                }
+            } {
+                break Err(e);
+            }
+
+            smol::future::yield_now().await;
+        };
+
+        drop(client_tx);
+
+        log::debug!("Handle receive messages dropped");
+
+        result
+    }
+
+    /// Send a request to an adapter and get a response back
+    /// Note: This function will block until a response is sent back from the adapter
+    pub async fn request<R: Request>(&self, arguments: R::Arguments) -> Result<R::Response> {
+        let serialized_arguments = serde_json::to_value(arguments)?;
+
+        let (callback_tx, callback_rx) = oneshot::channel::<Result<Response>>();
+
+        let sequence_id = self.next_sequence_id();
+
+        let request = crate::messages::Request {
+            seq: sequence_id,
+            command: R::COMMAND.to_string(),
+            arguments: Some(serialized_arguments),
+        };
+
+        self.transport_delegate
+            .add_pending_request(sequence_id, callback_tx)
+            .await;
+
+        log::debug!(
+            "Client {} send `{}` request with sequence_id: {}",
+            self.id.0,
+            R::COMMAND.to_string(),
+            sequence_id
+        );
+
+        self.send_message(Message::Request(request)).await?;
+
+        let mut timeout = self.executor.timer(DAP_REQUEST_TIMEOUT).fuse();
+        let command = R::COMMAND.to_string();
+
+        select! {
+            response = callback_rx.fuse() => {
+                log::debug!(
+                    "Client {} received response for: `{}` sequence_id: {}",
+                    self.id.0,
+                    command,
+                    sequence_id
+                );
+
+                let response = response??;
+                match response.success {
+                    true => Ok(serde_json::from_value(response.body.unwrap_or_default())?),
+                    false => Err(anyhow!("Request failed")),
+                }
+            }
+
+            _ = timeout => {
+                self.transport_delegate.cancel_pending_request(&sequence_id).await;
+                log::error!("Cancelled DAP request for {command:?} id {sequence_id} which took over {DAP_REQUEST_TIMEOUT:?}");
+                anyhow::bail!("DAP request timeout");
+            }
+        }
+    }
+
+    pub async fn send_message(&self, message: Message) -> Result<()> {
+        self.transport_delegate.send_message(message).await
+    }
+
+    pub fn id(&self) -> SessionId {
+        self.id
+    }
+
+    pub fn binary(&self) -> &DebugAdapterBinary {
+        &self.binary
+    }
+
+    /// Get the next sequence id to be used in a request
+    pub fn next_sequence_id(&self) -> u64 {
+        self.sequence_count.fetch_add(1, Ordering::Relaxed)
+    }
+
+    pub async fn shutdown(&self) -> Result<()> {
+        self.transport_delegate.shutdown().await
+    }
+
+    pub fn has_adapter_logs(&self) -> bool {
+        self.transport_delegate.has_adapter_logs()
+    }
+
+    pub fn add_log_handler<F>(&self, f: F, kind: LogKind)
+    where
+        F: 'static + Send + FnMut(IoKind, &str),
+    {
+        self.transport_delegate.add_log_handler(f, kind);
+    }
+
+    #[cfg(any(test, feature = "test-support"))]
+    pub async fn on_request<R: dap_types::requests::Request, F>(&self, handler: F)
+    where
+        F: 'static
+            + Send
+            + FnMut(u64, R::Arguments) -> Result<R::Response, dap_types::ErrorResponse>,
+    {
+        let transport = self.transport_delegate.transport().as_fake();
+        transport.on_request::<R, F>(handler).await;
+    }
+
+    #[cfg(any(test, feature = "test-support"))]
+    pub async fn fake_reverse_request<R: dap_types::requests::Request>(&self, args: R::Arguments) {
+        self.send_message(Message::Request(dap_types::messages::Request {
+            seq: self.sequence_count.load(Ordering::Relaxed),
+            command: R::COMMAND.into(),
+            arguments: serde_json::to_value(args).ok(),
+        }))
+        .await
+        .unwrap();
+    }
+
+    #[cfg(any(test, feature = "test-support"))]
+    pub async fn on_response<R: dap_types::requests::Request, F>(&self, handler: F)
+    where
+        F: 'static + Send + Fn(Response),
+    {
+        let transport = self.transport_delegate.transport().as_fake();
+        transport.on_response::<R, F>(handler).await;
+    }
+
+    #[cfg(any(test, feature = "test-support"))]
+    pub async fn fake_event(&self, event: dap_types::messages::Events) {
+        self.send_message(Message::Event(Box::new(event)))
+            .await
+            .unwrap();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{client::DebugAdapterClient, debugger_settings::DebuggerSettings};
+    use dap_types::{
+        messages::Events,
+        requests::{Initialize, Request, RunInTerminal},
+        Capabilities, InitializeRequestArguments, InitializeRequestArgumentsPathFormat,
+        RunInTerminalRequestArguments,
+    };
+    use gpui::TestAppContext;
+    use serde_json::json;
+    use settings::{Settings, SettingsStore};
+    use std::sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    };
+
+    pub fn init_test(cx: &mut gpui::TestAppContext) {
+        if std::env::var("RUST_LOG").is_ok() {
+            env_logger::try_init().ok();
+        }
+
+        cx.update(|cx| {
+            let settings = SettingsStore::test(cx);
+            cx.set_global(settings);
+            DebuggerSettings::register(cx);
+        });
+    }
+
+    #[gpui::test]
+    pub async fn test_initialize_client(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let client = DebugAdapterClient::start(
+            crate::client::SessionId(1),
+            DebugAdapterBinary {
+                command: "command".into(),
+                arguments: Default::default(),
+                envs: Default::default(),
+                connection: None,
+                cwd: None,
+            },
+            Box::new(|_, _| panic!("Did not expect to hit this code path")),
+            cx.to_async(),
+        )
+        .await
+        .unwrap();
+
+        client
+            .on_request::<Initialize, _>(move |_, _| {
+                Ok(dap_types::Capabilities {
+                    supports_configuration_done_request: Some(true),
+                    ..Default::default()
+                })
+            })
+            .await;
+
+        cx.run_until_parked();
+
+        let response = client
+            .request::<Initialize>(InitializeRequestArguments {
+                client_id: Some("zed".to_owned()),
+                client_name: Some("Zed".to_owned()),
+                adapter_id: "fake-adapter".to_owned(),
+                locale: Some("en-US".to_owned()),
+                path_format: Some(InitializeRequestArgumentsPathFormat::Path),
+                supports_variable_type: Some(true),
+                supports_variable_paging: Some(false),
+                supports_run_in_terminal_request: Some(true),
+                supports_memory_references: Some(true),
+                supports_progress_reporting: Some(false),
+                supports_invalidated_event: Some(false),
+                lines_start_at1: Some(true),
+                columns_start_at1: Some(true),
+                supports_memory_event: Some(false),
+                supports_args_can_be_interpreted_by_shell: Some(false),
+                supports_start_debugging_request: Some(true),
+            })
+            .await
+            .unwrap();
+
+        cx.run_until_parked();
+
+        assert_eq!(
+            dap_types::Capabilities {
+                supports_configuration_done_request: Some(true),
+                ..Default::default()
+            },
+            response
+        );
+
+        client.shutdown().await.unwrap();
+    }
+
+    #[gpui::test]
+    pub async fn test_calls_event_handler(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let called_event_handler = Arc::new(AtomicBool::new(false));
+
+        let client = DebugAdapterClient::start(
+            crate::client::SessionId(1),
+            DebugAdapterBinary {
+                command: "command".into(),
+                arguments: Default::default(),
+                envs: Default::default(),
+                connection: None,
+                cwd: None,
+            },
+            Box::new({
+                let called_event_handler = called_event_handler.clone();
+                move |event, _| {
+                    called_event_handler.store(true, Ordering::SeqCst);
+
+                    assert_eq!(
+                        Message::Event(Box::new(Events::Initialized(
+                            Some(Capabilities::default())
+                        ))),
+                        event
+                    );
+                }
+            }),
+            cx.to_async(),
+        )
+        .await
+        .unwrap();
+
+        cx.run_until_parked();
+
+        client
+            .fake_event(Events::Initialized(Some(Capabilities::default())))
+            .await;
+
+        cx.run_until_parked();
+
+        assert!(
+            called_event_handler.load(std::sync::atomic::Ordering::SeqCst),
+            "Event handler was not called"
+        );
+
+        client.shutdown().await.unwrap();
+    }
+
+    #[gpui::test]
+    pub async fn test_calls_event_handler_for_reverse_request(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let called_event_handler = Arc::new(AtomicBool::new(false));
+
+        let client = DebugAdapterClient::start(
+            crate::client::SessionId(1),
+            DebugAdapterBinary {
+                command: "command".into(),
+                arguments: Default::default(),
+                envs: Default::default(),
+                connection: None,
+                cwd: None,
+            },
+            Box::new({
+                let called_event_handler = called_event_handler.clone();
+                move |event, _| {
+                    called_event_handler.store(true, Ordering::SeqCst);
+
+                    assert_eq!(
+                        Message::Request(dap_types::messages::Request {
+                            seq: 1,
+                            command: RunInTerminal::COMMAND.into(),
+                            arguments: Some(json!({
+                                "cwd": "/project/path/src",
+                                "args": ["node", "test.js"],
+                            }))
+                        }),
+                        event
+                    );
+                }
+            }),
+            cx.to_async(),
+        )
+        .await
+        .unwrap();
+
+        cx.run_until_parked();
+
+        client
+            .fake_reverse_request::<RunInTerminal>(RunInTerminalRequestArguments {
+                kind: None,
+                title: None,
+                cwd: "/project/path/src".into(),
+                args: vec!["node".into(), "test.js".into()],
+                env: None,
+                args_can_be_interpreted_by_shell: None,
+            })
+            .await;
+
+        cx.run_until_parked();
+
+        assert!(
+            called_event_handler.load(std::sync::atomic::Ordering::SeqCst),
+            "Event handler was not called"
+        );
+
+        client.shutdown().await.unwrap();
+    }
+}

crates/dap/src/debugger_settings.rs

@@ -0,0 +1,59 @@
+use dap_types::SteppingGranularity;
+use gpui::{App, Global};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use settings::{Settings, SettingsSources};
+
+#[derive(Serialize, Deserialize, JsonSchema, Clone, Copy)]
+#[serde(default)]
+pub struct DebuggerSettings {
+    /// Determines the stepping granularity.
+    ///
+    /// Default: line
+    pub stepping_granularity: SteppingGranularity,
+    /// Whether the breakpoints should be reused across Zed sessions.
+    ///
+    /// Default: true
+    pub save_breakpoints: bool,
+    /// Whether to show the debug button in the status bar.
+    ///
+    /// Default: true
+    pub button: bool,
+    /// Time in milliseconds until timeout error when connecting to a TCP debug adapter
+    ///
+    /// Default: 2000ms
+    pub timeout: u64,
+    /// Whether to log messages between active debug adapters and Zed
+    ///
+    /// Default: true
+    pub log_dap_communications: bool,
+    /// Whether to format dap messages in when adding them to debug adapter logger
+    ///
+    /// Default: true
+    pub format_dap_log_messages: bool,
+}
+
+impl Default for DebuggerSettings {
+    fn default() -> Self {
+        Self {
+            button: true,
+            save_breakpoints: true,
+            stepping_granularity: SteppingGranularity::Line,
+            timeout: 2000,
+            log_dap_communications: true,
+            format_dap_log_messages: true,
+        }
+    }
+}
+
+impl Settings for DebuggerSettings {
+    const KEY: Option<&'static str> = Some("debugger");
+
+    type FileContent = Self;
+
+    fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> anyhow::Result<Self> {
+        sources.json_merge()
+    }
+}
+
+impl Global for DebuggerSettings {}

crates/dap/src/lib.rs

@@ -0,0 +1,28 @@
+pub mod adapters;
+pub mod client;
+pub mod debugger_settings;
+pub mod proto_conversions;
+pub mod transport;
+
+pub use dap_types::*;
+pub use task::{DebugAdapterConfig, DebugAdapterKind, DebugRequestType};
+
+pub type ScopeId = u64;
+pub type VariableReference = u64;
+pub type StackFrameId = u64;
+
+#[cfg(any(test, feature = "test-support"))]
+pub use adapters::FakeAdapter;
+
+#[cfg(any(test, feature = "test-support"))]
+pub fn test_config() -> DebugAdapterConfig {
+    DebugAdapterConfig {
+        label: "test config".into(),
+        kind: DebugAdapterKind::Fake,
+        request: DebugRequestType::Launch,
+        program: None,
+        supports_attach: false,
+        cwd: None,
+        initialize_args: None,
+    }
+}

crates/dap/src/proto_conversions.rs

@@ -0,0 +1,638 @@
+use anyhow::{anyhow, Result};
+use client::proto::{
+    self, DapChecksum, DapChecksumAlgorithm, DapEvaluateContext, DapModule, DapScope,
+    DapScopePresentationHint, DapSource, DapSourcePresentationHint, DapStackFrame, DapVariable,
+    SetDebugClientCapabilities,
+};
+use dap_types::{
+    Capabilities, OutputEventCategory, OutputEventGroup, ScopePresentationHint, Source,
+};
+
+pub trait ProtoConversion {
+    type ProtoType;
+    type Output;
+
+    fn to_proto(&self) -> Self::ProtoType;
+    fn from_proto(payload: Self::ProtoType) -> Self::Output;
+}
+
+impl<T> ProtoConversion for Vec<T>
+where
+    T: ProtoConversion<Output = T>,
+{
+    type ProtoType = Vec<T::ProtoType>;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        self.iter().map(|item| item.to_proto()).collect()
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        payload
+            .into_iter()
+            .map(|item| T::from_proto(item))
+            .collect()
+    }
+}
+
+impl ProtoConversion for dap_types::Scope {
+    type ProtoType = DapScope;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        Self::ProtoType {
+            name: self.name.clone(),
+            presentation_hint: self
+                .presentation_hint
+                .as_ref()
+                .map(|hint| hint.to_proto().into()),
+            variables_reference: self.variables_reference,
+            named_variables: self.named_variables,
+            indexed_variables: self.indexed_variables,
+            expensive: self.expensive,
+            source: self.source.as_ref().map(Source::to_proto),
+            line: self.line,
+            end_line: self.end_line,
+            column: self.column,
+            end_column: self.end_column,
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        let presentation_hint = payload
+            .presentation_hint
+            .and_then(DapScopePresentationHint::from_i32);
+        Self {
+            name: payload.name,
+            presentation_hint: presentation_hint.map(ScopePresentationHint::from_proto),
+            variables_reference: payload.variables_reference,
+            named_variables: payload.named_variables,
+            indexed_variables: payload.indexed_variables,
+            expensive: payload.expensive,
+            source: payload.source.map(dap_types::Source::from_proto),
+            line: payload.line,
+            end_line: payload.end_line,
+            column: payload.column,
+            end_column: payload.end_column,
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::Variable {
+    type ProtoType = DapVariable;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        Self::ProtoType {
+            name: self.name.clone(),
+            value: self.value.clone(),
+            r#type: self.type_.clone(),
+            evaluate_name: self.evaluate_name.clone(),
+            variables_reference: self.variables_reference,
+            named_variables: self.named_variables,
+            indexed_variables: self.indexed_variables,
+            memory_reference: self.memory_reference.clone(),
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        Self {
+            name: payload.name,
+            value: payload.value,
+            type_: payload.r#type,
+            evaluate_name: payload.evaluate_name,
+            presentation_hint: None, // TODO Debugger Collab Add this
+            variables_reference: payload.variables_reference,
+            named_variables: payload.named_variables,
+            indexed_variables: payload.indexed_variables,
+            memory_reference: payload.memory_reference,
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::ScopePresentationHint {
+    type ProtoType = DapScopePresentationHint;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        match self {
+            dap_types::ScopePresentationHint::Locals => DapScopePresentationHint::Locals,
+            dap_types::ScopePresentationHint::Arguments => DapScopePresentationHint::Arguments,
+            dap_types::ScopePresentationHint::Registers => DapScopePresentationHint::Registers,
+            dap_types::ScopePresentationHint::ReturnValue => DapScopePresentationHint::ReturnValue,
+            dap_types::ScopePresentationHint::Unknown => DapScopePresentationHint::ScopeUnknown,
+            &_ => unreachable!(),
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        match payload {
+            DapScopePresentationHint::Locals => dap_types::ScopePresentationHint::Locals,
+            DapScopePresentationHint::Arguments => dap_types::ScopePresentationHint::Arguments,
+            DapScopePresentationHint::Registers => dap_types::ScopePresentationHint::Registers,
+            DapScopePresentationHint::ReturnValue => dap_types::ScopePresentationHint::ReturnValue,
+            DapScopePresentationHint::ScopeUnknown => dap_types::ScopePresentationHint::Unknown,
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::SourcePresentationHint {
+    type ProtoType = DapSourcePresentationHint;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        match self {
+            dap_types::SourcePresentationHint::Normal => DapSourcePresentationHint::SourceNormal,
+            dap_types::SourcePresentationHint::Emphasize => DapSourcePresentationHint::Emphasize,
+            dap_types::SourcePresentationHint::Deemphasize => {
+                DapSourcePresentationHint::Deemphasize
+            }
+            dap_types::SourcePresentationHint::Unknown => DapSourcePresentationHint::SourceUnknown,
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        match payload {
+            DapSourcePresentationHint::SourceNormal => dap_types::SourcePresentationHint::Normal,
+            DapSourcePresentationHint::Emphasize => dap_types::SourcePresentationHint::Emphasize,
+            DapSourcePresentationHint::Deemphasize => {
+                dap_types::SourcePresentationHint::Deemphasize
+            }
+            DapSourcePresentationHint::SourceUnknown => dap_types::SourcePresentationHint::Unknown,
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::Checksum {
+    type ProtoType = DapChecksum;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        DapChecksum {
+            algorithm: self.algorithm.to_proto().into(),
+            checksum: self.checksum.clone(),
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        Self {
+            algorithm: dap_types::ChecksumAlgorithm::from_proto(payload.algorithm()),
+            checksum: payload.checksum,
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::ChecksumAlgorithm {
+    type ProtoType = DapChecksumAlgorithm;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        match self {
+            dap_types::ChecksumAlgorithm::Md5 => DapChecksumAlgorithm::Md5,
+            dap_types::ChecksumAlgorithm::Sha1 => DapChecksumAlgorithm::Sha1,
+            dap_types::ChecksumAlgorithm::Sha256 => DapChecksumAlgorithm::Sha256,
+            dap_types::ChecksumAlgorithm::Timestamp => DapChecksumAlgorithm::Timestamp,
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        match payload {
+            DapChecksumAlgorithm::Md5 => dap_types::ChecksumAlgorithm::Md5,
+            DapChecksumAlgorithm::Sha1 => dap_types::ChecksumAlgorithm::Sha1,
+            DapChecksumAlgorithm::Sha256 => dap_types::ChecksumAlgorithm::Sha256,
+            DapChecksumAlgorithm::Timestamp => dap_types::ChecksumAlgorithm::Timestamp,
+            DapChecksumAlgorithm::ChecksumAlgorithmUnspecified => unreachable!(),
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::Source {
+    type ProtoType = DapSource;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        Self::ProtoType {
+            name: self.name.clone(),
+            path: self.path.clone(),
+            source_reference: self.source_reference,
+            presentation_hint: self.presentation_hint.map(|hint| hint.to_proto().into()),
+            origin: self.origin.clone(),
+            sources: self
+                .sources
+                .clone()
+                .map(|src| src.to_proto())
+                .unwrap_or_default(),
+            adapter_data: Default::default(), // TODO Debugger Collab
+            checksums: self
+                .checksums
+                .clone()
+                .map(|c| c.to_proto())
+                .unwrap_or_default(),
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        Self {
+            name: payload.name.clone(),
+            path: payload.path.clone(),
+            source_reference: payload.source_reference,
+            presentation_hint: payload
+                .presentation_hint
+                .and_then(DapSourcePresentationHint::from_i32)
+                .map(dap_types::SourcePresentationHint::from_proto),
+            origin: payload.origin.clone(),
+            sources: Some(Vec::<dap_types::Source>::from_proto(payload.sources)),
+            checksums: Some(Vec::<dap_types::Checksum>::from_proto(payload.checksums)),
+            adapter_data: None, // TODO Debugger Collab
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::StackFrame {
+    type ProtoType = DapStackFrame;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        Self::ProtoType {
+            id: self.id,
+            name: self.name.clone(),
+            source: self.source.as_ref().map(|src| src.to_proto()),
+            line: self.line,
+            column: self.column,
+            end_line: self.end_line,
+            end_column: self.end_column,
+            can_restart: self.can_restart,
+            instruction_pointer_reference: self.instruction_pointer_reference.clone(),
+            module_id: None,         // TODO Debugger Collab
+            presentation_hint: None, // TODO Debugger Collab
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        Self {
+            id: payload.id,
+            name: payload.name,
+            source: payload.source.map(dap_types::Source::from_proto),
+            line: payload.line,
+            column: payload.column,
+            end_line: payload.end_line,
+            end_column: payload.end_column,
+            can_restart: payload.can_restart,
+            instruction_pointer_reference: payload.instruction_pointer_reference,
+            module_id: None,         // TODO Debugger Collab
+            presentation_hint: None, // TODO Debugger Collab
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::Module {
+    type ProtoType = DapModule;
+    type Output = Result<Self>;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        let id = match &self.id {
+            dap_types::ModuleId::Number(num) => proto::dap_module_id::Id::Number(*num),
+            dap_types::ModuleId::String(string) => proto::dap_module_id::Id::String(string.clone()),
+        };
+
+        DapModule {
+            id: Some(proto::DapModuleId { id: Some(id) }),
+            name: self.name.clone(),
+            path: self.path.clone(),
+            is_optimized: self.is_optimized,
+            is_user_code: self.is_user_code,
+            version: self.version.clone(),
+            symbol_status: self.symbol_status.clone(),
+            symbol_file_path: self.symbol_file_path.clone(),
+            date_time_stamp: self.date_time_stamp.clone(),
+            address_range: self.address_range.clone(),
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Result<Self> {
+        let id = match payload
+            .id
+            .ok_or(anyhow!("All DapModule proto messages must have an id"))?
+            .id
+            .ok_or(anyhow!("All DapModuleID proto messages must have an id"))?
+        {
+            proto::dap_module_id::Id::String(string) => dap_types::ModuleId::String(string),
+            proto::dap_module_id::Id::Number(num) => dap_types::ModuleId::Number(num),
+        };
+
+        Ok(Self {
+            id,
+            name: payload.name,
+            path: payload.path,
+            is_optimized: payload.is_optimized,
+            is_user_code: payload.is_user_code,
+            version: payload.version,
+            symbol_status: payload.symbol_status,
+            symbol_file_path: payload.symbol_file_path,
+            date_time_stamp: payload.date_time_stamp,
+            address_range: payload.address_range,
+        })
+    }
+}
+
+pub fn capabilities_from_proto(payload: &SetDebugClientCapabilities) -> Capabilities {
+    Capabilities {
+        supports_loaded_sources_request: Some(payload.supports_loaded_sources_request),
+        supports_modules_request: Some(payload.supports_modules_request),
+        supports_restart_request: Some(payload.supports_restart_request),
+        supports_set_expression: Some(payload.supports_set_expression),
+        supports_single_thread_execution_requests: Some(
+            payload.supports_single_thread_execution_requests,
+        ),
+        supports_step_back: Some(payload.supports_step_back),
+        supports_stepping_granularity: Some(payload.supports_stepping_granularity),
+        supports_terminate_threads_request: Some(payload.supports_terminate_threads_request),
+        supports_restart_frame: Some(payload.supports_restart_frame_request),
+        supports_clipboard_context: Some(payload.supports_clipboard_context),
+        ..Default::default()
+    }
+}
+
+pub fn capabilities_to_proto(
+    capabilities: &Capabilities,
+    project_id: u64,
+    session_id: u64,
+) -> SetDebugClientCapabilities {
+    SetDebugClientCapabilities {
+        session_id,
+        project_id,
+        supports_loaded_sources_request: capabilities
+            .supports_loaded_sources_request
+            .unwrap_or_default(),
+        supports_modules_request: capabilities.supports_modules_request.unwrap_or_default(),
+        supports_restart_request: capabilities.supports_restart_request.unwrap_or_default(),
+        supports_set_expression: capabilities.supports_set_expression.unwrap_or_default(),
+        supports_single_thread_execution_requests: capabilities
+            .supports_single_thread_execution_requests
+            .unwrap_or_default(),
+        supports_step_back: capabilities.supports_step_back.unwrap_or_default(),
+        supports_stepping_granularity: capabilities
+            .supports_stepping_granularity
+            .unwrap_or_default(),
+        supports_terminate_threads_request: capabilities
+            .supports_terminate_threads_request
+            .unwrap_or_default(),
+        supports_restart_frame_request: capabilities.supports_restart_frame.unwrap_or_default(),
+        supports_clipboard_context: capabilities.supports_clipboard_context.unwrap_or_default(),
+    }
+}
+
+impl ProtoConversion for dap_types::SteppingGranularity {
+    type ProtoType = proto::SteppingGranularity;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        match self {
+            dap_types::SteppingGranularity::Statement => proto::SteppingGranularity::Statement,
+            dap_types::SteppingGranularity::Line => proto::SteppingGranularity::Line,
+            dap_types::SteppingGranularity::Instruction => proto::SteppingGranularity::Instruction,
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        match payload {
+            proto::SteppingGranularity::Line => dap_types::SteppingGranularity::Line,
+            proto::SteppingGranularity::Instruction => dap_types::SteppingGranularity::Instruction,
+            proto::SteppingGranularity::Statement => dap_types::SteppingGranularity::Statement,
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::OutputEventCategory {
+    type ProtoType = proto::DapOutputCategory;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        match self {
+            Self::Console => proto::DapOutputCategory::ConsoleOutput,
+            Self::Important => proto::DapOutputCategory::Important,
+            Self::Stdout => proto::DapOutputCategory::Stdout,
+            Self::Stderr => proto::DapOutputCategory::Stderr,
+            _ => proto::DapOutputCategory::Unknown,
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        match payload {
+            proto::DapOutputCategory::ConsoleOutput => Self::Console,
+            proto::DapOutputCategory::Important => Self::Important,
+            proto::DapOutputCategory::Stdout => Self::Stdout,
+            proto::DapOutputCategory::Stderr => Self::Stderr,
+            proto::DapOutputCategory::Unknown => Self::Unknown,
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::OutputEvent {
+    type ProtoType = proto::DapOutputEvent;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        proto::DapOutputEvent {
+            category: self
+                .category
+                .as_ref()
+                .map(|category| category.to_proto().into()),
+            output: self.output.clone(),
+            variables_reference: self.variables_reference,
+            source: self.source.as_ref().map(|source| source.to_proto()),
+            line: self.line.map(|line| line as u32),
+            column: self.column.map(|column| column as u32),
+            group: self.group.map(|group| group.to_proto().into()),
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        dap_types::OutputEvent {
+            category: payload
+                .category
+                .and_then(proto::DapOutputCategory::from_i32)
+                .map(OutputEventCategory::from_proto),
+            output: payload.output.clone(),
+            variables_reference: payload.variables_reference,
+            source: payload.source.map(Source::from_proto),
+            line: payload.line.map(|line| line as u64),
+            column: payload.column.map(|column| column as u64),
+            group: payload
+                .group
+                .and_then(proto::DapOutputEventGroup::from_i32)
+                .map(OutputEventGroup::from_proto),
+            data: None,
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::OutputEventGroup {
+    type ProtoType = proto::DapOutputEventGroup;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        match self {
+            dap_types::OutputEventGroup::Start => proto::DapOutputEventGroup::Start,
+            dap_types::OutputEventGroup::StartCollapsed => {
+                proto::DapOutputEventGroup::StartCollapsed
+            }
+            dap_types::OutputEventGroup::End => proto::DapOutputEventGroup::End,
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        match payload {
+            proto::DapOutputEventGroup::Start => Self::Start,
+            proto::DapOutputEventGroup::StartCollapsed => Self::StartCollapsed,
+            proto::DapOutputEventGroup::End => Self::End,
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::CompletionItem {
+    type ProtoType = proto::DapCompletionItem;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        proto::DapCompletionItem {
+            label: self.label.clone(),
+            text: self.text.clone(),
+            detail: self.detail.clone(),
+            typ: self
+                .type_
+                .as_ref()
+                .map(ProtoConversion::to_proto)
+                .map(|typ| typ.into()),
+            start: self.start,
+            length: self.length,
+            selection_start: self.selection_start,
+            selection_length: self.selection_length,
+            sort_text: self.sort_text.clone(),
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        let typ = payload.typ(); // todo(debugger): This might be a potential issue/bug because it defaults to a type when it's None
+
+        Self {
+            label: payload.label,
+            detail: payload.detail,
+            sort_text: payload.sort_text,
+            text: payload.text.clone(),
+            type_: Some(dap_types::CompletionItemType::from_proto(typ)),
+            start: payload.start,
+            length: payload.length,
+            selection_start: payload.selection_start,
+            selection_length: payload.selection_length,
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::EvaluateArgumentsContext {
+    type ProtoType = DapEvaluateContext;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        match self {
+            dap_types::EvaluateArgumentsContext::Variables => {
+                proto::DapEvaluateContext::EvaluateVariables
+            }
+            dap_types::EvaluateArgumentsContext::Watch => proto::DapEvaluateContext::Watch,
+            dap_types::EvaluateArgumentsContext::Hover => proto::DapEvaluateContext::Hover,
+            dap_types::EvaluateArgumentsContext::Repl => proto::DapEvaluateContext::Repl,
+            dap_types::EvaluateArgumentsContext::Clipboard => proto::DapEvaluateContext::Clipboard,
+            dap_types::EvaluateArgumentsContext::Unknown => {
+                proto::DapEvaluateContext::EvaluateUnknown
+            }
+            _ => proto::DapEvaluateContext::EvaluateUnknown,
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        match payload {
+            proto::DapEvaluateContext::EvaluateVariables => {
+                dap_types::EvaluateArgumentsContext::Variables
+            }
+            proto::DapEvaluateContext::Watch => dap_types::EvaluateArgumentsContext::Watch,
+            proto::DapEvaluateContext::Hover => dap_types::EvaluateArgumentsContext::Hover,
+            proto::DapEvaluateContext::Repl => dap_types::EvaluateArgumentsContext::Repl,
+            proto::DapEvaluateContext::Clipboard => dap_types::EvaluateArgumentsContext::Clipboard,
+            proto::DapEvaluateContext::EvaluateUnknown => {
+                dap_types::EvaluateArgumentsContext::Unknown
+            }
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::CompletionItemType {
+    type ProtoType = proto::DapCompletionItemType;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        match self {
+            dap_types::CompletionItemType::Class => proto::DapCompletionItemType::Class,
+            dap_types::CompletionItemType::Color => proto::DapCompletionItemType::Color,
+            dap_types::CompletionItemType::Constructor => proto::DapCompletionItemType::Constructor,
+            dap_types::CompletionItemType::Customcolor => proto::DapCompletionItemType::Customcolor,
+            dap_types::CompletionItemType::Enum => proto::DapCompletionItemType::Enum,
+            dap_types::CompletionItemType::Field => proto::DapCompletionItemType::Field,
+            dap_types::CompletionItemType::File => proto::DapCompletionItemType::CompletionItemFile,
+            dap_types::CompletionItemType::Function => proto::DapCompletionItemType::Function,
+            dap_types::CompletionItemType::Interface => proto::DapCompletionItemType::Interface,
+            dap_types::CompletionItemType::Keyword => proto::DapCompletionItemType::Keyword,
+            dap_types::CompletionItemType::Method => proto::DapCompletionItemType::Method,
+            dap_types::CompletionItemType::Module => proto::DapCompletionItemType::Module,
+            dap_types::CompletionItemType::Property => proto::DapCompletionItemType::Property,
+            dap_types::CompletionItemType::Reference => proto::DapCompletionItemType::Reference,
+            dap_types::CompletionItemType::Snippet => proto::DapCompletionItemType::Snippet,
+            dap_types::CompletionItemType::Text => proto::DapCompletionItemType::Text,
+            dap_types::CompletionItemType::Unit => proto::DapCompletionItemType::Unit,
+            dap_types::CompletionItemType::Value => proto::DapCompletionItemType::Value,
+            dap_types::CompletionItemType::Variable => proto::DapCompletionItemType::Variable,
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        match payload {
+            proto::DapCompletionItemType::Class => dap_types::CompletionItemType::Class,
+            proto::DapCompletionItemType::Color => dap_types::CompletionItemType::Color,
+            proto::DapCompletionItemType::CompletionItemFile => dap_types::CompletionItemType::File,
+            proto::DapCompletionItemType::Constructor => dap_types::CompletionItemType::Constructor,
+            proto::DapCompletionItemType::Customcolor => dap_types::CompletionItemType::Customcolor,
+            proto::DapCompletionItemType::Enum => dap_types::CompletionItemType::Enum,
+            proto::DapCompletionItemType::Field => dap_types::CompletionItemType::Field,
+            proto::DapCompletionItemType::Function => dap_types::CompletionItemType::Function,
+            proto::DapCompletionItemType::Interface => dap_types::CompletionItemType::Interface,
+            proto::DapCompletionItemType::Keyword => dap_types::CompletionItemType::Keyword,
+            proto::DapCompletionItemType::Method => dap_types::CompletionItemType::Method,
+            proto::DapCompletionItemType::Module => dap_types::CompletionItemType::Module,
+            proto::DapCompletionItemType::Property => dap_types::CompletionItemType::Property,
+            proto::DapCompletionItemType::Reference => dap_types::CompletionItemType::Reference,
+            proto::DapCompletionItemType::Snippet => dap_types::CompletionItemType::Snippet,
+            proto::DapCompletionItemType::Text => dap_types::CompletionItemType::Text,
+            proto::DapCompletionItemType::Unit => dap_types::CompletionItemType::Unit,
+            proto::DapCompletionItemType::Value => dap_types::CompletionItemType::Value,
+            proto::DapCompletionItemType::Variable => dap_types::CompletionItemType::Variable,
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::Thread {
+    type ProtoType = proto::DapThread;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        proto::DapThread {
+            id: self.id,
+            name: self.name.clone(),
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        Self {
+            id: payload.id,
+            name: payload.name,
+        }
+    }
+}

crates/dap/src/transport.rs

@@ -0,0 +1,882 @@
+use anyhow::{anyhow, Context, Result};
+use dap_types::{
+    messages::{Message, Response},
+    ErrorResponse,
+};
+use futures::{channel::oneshot, select, AsyncRead, AsyncReadExt as _, AsyncWrite, FutureExt as _};
+use gpui::AsyncApp;
+use settings::Settings as _;
+use smallvec::SmallVec;
+use smol::{
+    channel::{unbounded, Receiver, Sender},
+    io::{AsyncBufReadExt as _, AsyncWriteExt, BufReader},
+    lock::Mutex,
+    net::{TcpListener, TcpStream},
+    process::Child,
+};
+use std::{
+    collections::HashMap,
+    net::{Ipv4Addr, SocketAddrV4},
+    process::Stdio,
+    sync::Arc,
+    time::Duration,
+};
+use task::TCPHost;
+use util::ResultExt as _;
+
+use crate::{adapters::DebugAdapterBinary, debugger_settings::DebuggerSettings};
+
+pub type IoHandler = Box<dyn Send + FnMut(IoKind, &str)>;
+
+#[derive(PartialEq, Eq, Clone, Copy)]
+pub enum LogKind {
+    Adapter,
+    Rpc,
+}
+
+pub enum IoKind {
+    StdIn,
+    StdOut,
+    StdErr,
+}
+
+pub struct TransportPipe {
+    input: Box<dyn AsyncWrite + Unpin + Send + 'static>,
+    output: Box<dyn AsyncRead + Unpin + Send + 'static>,
+    stdout: Option<Box<dyn AsyncRead + Unpin + Send + 'static>>,
+    stderr: Option<Box<dyn AsyncRead + Unpin + Send + 'static>>,
+}
+
+impl TransportPipe {
+    pub fn new(
+        input: Box<dyn AsyncWrite + Unpin + Send + 'static>,
+        output: Box<dyn AsyncRead + Unpin + Send + 'static>,
+        stdout: Option<Box<dyn AsyncRead + Unpin + Send + 'static>>,
+        stderr: Option<Box<dyn AsyncRead + Unpin + Send + 'static>>,
+    ) -> Self {
+        TransportPipe {
+            input,
+            output,
+            stdout,
+            stderr,
+        }
+    }
+}
+
+type Requests = Arc<Mutex<HashMap<u64, oneshot::Sender<Result<Response>>>>>;
+type LogHandlers = Arc<parking_lot::Mutex<SmallVec<[(LogKind, IoHandler); 2]>>>;
+
+pub enum Transport {
+    Stdio(StdioTransport),
+    Tcp(TcpTransport),
+    #[cfg(any(test, feature = "test-support"))]
+    Fake(FakeTransport),
+}
+
+impl Transport {
+    async fn start(binary: &DebugAdapterBinary, cx: AsyncApp) -> Result<(TransportPipe, Self)> {
+        #[cfg(any(test, feature = "test-support"))]
+        return FakeTransport::start(cx)
+            .await
+            .map(|(transports, fake)| (transports, Self::Fake(fake)));
+
+        if binary.connection.is_some() {
+            TcpTransport::start(binary, cx)
+                .await
+                .map(|(transports, tcp)| (transports, Self::Tcp(tcp)))
+        } else {
+            StdioTransport::start(binary, cx)
+                .await
+                .map(|(transports, stdio)| (transports, Self::Stdio(stdio)))
+        }
+    }
+
+    fn has_adapter_logs(&self) -> bool {
+        match self {
+            Transport::Stdio(stdio_transport) => stdio_transport.has_adapter_logs(),
+            Transport::Tcp(tcp_transport) => tcp_transport.has_adapter_logs(),
+            #[cfg(any(test, feature = "test-support"))]
+            Transport::Fake(fake_transport) => fake_transport.has_adapter_logs(),
+        }
+    }
+
+    async fn kill(&self) -> Result<()> {
+        match self {
+            Transport::Stdio(stdio_transport) => stdio_transport.kill().await,
+            Transport::Tcp(tcp_transport) => tcp_transport.kill().await,
+            #[cfg(any(test, feature = "test-support"))]
+            Transport::Fake(fake_transport) => fake_transport.kill().await,
+        }
+    }
+
+    #[cfg(any(test, feature = "test-support"))]
+    pub(crate) fn as_fake(&self) -> &FakeTransport {
+        match self {
+            Transport::Fake(fake_transport) => fake_transport,
+            _ => panic!("Not a fake transport layer"),
+        }
+    }
+}
+
+pub(crate) struct TransportDelegate {
+    log_handlers: LogHandlers,
+    current_requests: Requests,
+    pending_requests: Requests,
+    transport: Transport,
+    server_tx: Arc<Mutex<Option<Sender<Message>>>>,
+}
+
+impl TransportDelegate {
+    pub(crate) async fn start(
+        binary: &DebugAdapterBinary,
+        cx: AsyncApp,
+    ) -> Result<((Receiver<Message>, Sender<Message>), Self)> {
+        let (transport_pipes, transport) = Transport::start(binary, cx.clone()).await?;
+        let mut this = Self {
+            transport,
+            server_tx: Default::default(),
+            log_handlers: Default::default(),
+            current_requests: Default::default(),
+            pending_requests: Default::default(),
+        };
+        let messages = this.start_handlers(transport_pipes, cx).await?;
+        Ok((messages, this))
+    }
+
+    async fn start_handlers(
+        &mut self,
+        mut params: TransportPipe,
+        cx: AsyncApp,
+    ) -> Result<(Receiver<Message>, Sender<Message>)> {
+        let (client_tx, server_rx) = unbounded::<Message>();
+        let (server_tx, client_rx) = unbounded::<Message>();
+
+        let log_dap_communications =
+            cx.update(|cx| DebuggerSettings::get_global(cx).log_dap_communications)
+                .with_context(|| "Failed to get Debugger Setting log dap communications error in transport::start_handlers. Defaulting to false")
+                .unwrap_or(false);
+
+        let log_handler = if log_dap_communications {
+            Some(self.log_handlers.clone())
+        } else {
+            None
+        };
+
+        cx.update(|cx| {
+            if let Some(stdout) = params.stdout.take() {
+                cx.background_executor()
+                    .spawn(Self::handle_adapter_log(stdout, log_handler.clone()))
+                    .detach_and_log_err(cx);
+            }
+
+            cx.background_executor()
+                .spawn(Self::handle_output(
+                    params.output,
+                    client_tx,
+                    self.pending_requests.clone(),
+                    log_handler.clone(),
+                ))
+                .detach_and_log_err(cx);
+
+            if let Some(stderr) = params.stderr.take() {
+                cx.background_executor()
+                    .spawn(Self::handle_error(stderr, self.log_handlers.clone()))
+                    .detach_and_log_err(cx);
+            }
+
+            cx.background_executor()
+                .spawn(Self::handle_input(
+                    params.input,
+                    client_rx,
+                    self.current_requests.clone(),
+                    self.pending_requests.clone(),
+                    log_handler.clone(),
+                ))
+                .detach_and_log_err(cx);
+        })?;
+
+        {
+            let mut lock = self.server_tx.lock().await;
+            *lock = Some(server_tx.clone());
+        }
+
+        Ok((server_rx, server_tx))
+    }
+
+    pub(crate) async fn add_pending_request(
+        &self,
+        sequence_id: u64,
+        request: oneshot::Sender<Result<Response>>,
+    ) {
+        let mut pending_requests = self.pending_requests.lock().await;
+        pending_requests.insert(sequence_id, request);
+    }
+
+    pub(crate) async fn cancel_pending_request(&self, sequence_id: &u64) {
+        let mut pending_requests = self.pending_requests.lock().await;
+        pending_requests.remove(sequence_id);
+    }
+
+    pub(crate) async fn send_message(&self, message: Message) -> Result<()> {
+        if let Some(server_tx) = self.server_tx.lock().await.as_ref() {
+            server_tx
+                .send(message)
+                .await
+                .map_err(|e| anyhow!("Failed to send message: {}", e))
+        } else {
+            Err(anyhow!("Server tx already dropped"))
+        }
+    }
+
+    async fn handle_adapter_log<Stdout>(
+        stdout: Stdout,
+        log_handlers: Option<LogHandlers>,
+    ) -> Result<()>
+    where
+        Stdout: AsyncRead + Unpin + Send + 'static,
+    {
+        let mut reader = BufReader::new(stdout);
+        let mut line = String::new();
+
+        let result = loop {
+            line.truncate(0);
+
+            let bytes_read = match reader.read_line(&mut line).await {
+                Ok(bytes_read) => bytes_read,
+                Err(e) => break Err(e.into()),
+            };
+
+            if bytes_read == 0 {
+                break Err(anyhow!("Debugger log stream closed"));
+            }
+
+            if let Some(log_handlers) = log_handlers.as_ref() {
+                for (kind, handler) in log_handlers.lock().iter_mut() {
+                    if matches!(kind, LogKind::Adapter) {
+                        handler(IoKind::StdOut, line.as_str());
+                    }
+                }
+            }
+
+            smol::future::yield_now().await;
+        };
+
+        log::debug!("Handle adapter log dropped");
+
+        result
+    }
+
+    fn build_rpc_message(message: String) -> String {
+        format!("Content-Length: {}\r\n\r\n{}", message.len(), message)
+    }
+
+    async fn handle_input<Stdin>(
+        mut server_stdin: Stdin,
+        client_rx: Receiver<Message>,
+        current_requests: Requests,
+        pending_requests: Requests,
+        log_handlers: Option<LogHandlers>,
+    ) -> Result<()>
+    where
+        Stdin: AsyncWrite + Unpin + Send + 'static,
+    {
+        let result = loop {
+            match client_rx.recv().await {
+                Ok(message) => {
+                    if let Message::Request(request) = &message {
+                        if let Some(sender) = current_requests.lock().await.remove(&request.seq) {
+                            pending_requests.lock().await.insert(request.seq, sender);
+                        }
+                    }
+
+                    let message = match serde_json::to_string(&message) {
+                        Ok(message) => message,
+                        Err(e) => break Err(e.into()),
+                    };
+
+                    if let Some(log_handlers) = log_handlers.as_ref() {
+                        for (kind, log_handler) in log_handlers.lock().iter_mut() {
+                            if matches!(kind, LogKind::Rpc) {
+                                log_handler(IoKind::StdIn, &message);
+                            }
+                        }
+                    }
+
+                    if let Err(e) = server_stdin
+                        .write_all(Self::build_rpc_message(message).as_bytes())
+                        .await
+                    {
+                        break Err(e.into());
+                    }
+
+                    if let Err(e) = server_stdin.flush().await {
+                        break Err(e.into());
+                    }
+                }
+                Err(error) => break Err(error.into()),
+            }
+
+            smol::future::yield_now().await;
+        };
+
+        log::debug!("Handle adapter input dropped");
+
+        result
+    }
+
+    async fn handle_output<Stdout>(
+        server_stdout: Stdout,
+        client_tx: Sender<Message>,
+        pending_requests: Requests,
+        log_handlers: Option<LogHandlers>,
+    ) -> Result<()>
+    where
+        Stdout: AsyncRead + Unpin + Send + 'static,
+    {
+        let mut recv_buffer = String::new();
+        let mut reader = BufReader::new(server_stdout);
+
+        let result = loop {
+            let message =
+                Self::receive_server_message(&mut reader, &mut recv_buffer, log_handlers.as_ref())
+                    .await;
+
+            match message {
+                Ok(Message::Response(res)) => {
+                    if let Some(tx) = pending_requests.lock().await.remove(&res.request_seq) {
+                        if let Err(e) = tx.send(Self::process_response(res)) {
+                            break Err(anyhow!("Failed to send response: {:?}", e));
+                        }
+                    } else {
+                        client_tx.send(Message::Response(res)).await?;
+                    };
+                }
+                Ok(message) => {
+                    client_tx.send(message).await?;
+                }
+                Err(e) => break Err(e),
+            }
+
+            smol::future::yield_now().await;
+        };
+
+        drop(client_tx);
+
+        log::debug!("Handle adapter output dropped");
+
+        result
+    }
+
+    async fn handle_error<Stderr>(stderr: Stderr, log_handlers: LogHandlers) -> Result<()>
+    where
+        Stderr: AsyncRead + Unpin + Send + 'static,
+    {
+        let mut buffer = String::new();
+
+        let mut reader = BufReader::new(stderr);
+
+        let result = loop {
+            match reader.read_line(&mut buffer).await {
+                Ok(0) => break Err(anyhow!("debugger error stream closed")),
+                Ok(_) => {
+                    for (kind, log_handler) in log_handlers.lock().iter_mut() {
+                        if matches!(kind, LogKind::Adapter) {
+                            log_handler(IoKind::StdErr, buffer.as_str());
+                        }
+                    }
+
+                    buffer.truncate(0);
+                }
+                Err(error) => break Err(error.into()),
+            }
+
+            smol::future::yield_now().await;
+        };
+
+        log::debug!("Handle adapter error dropped");
+
+        result
+    }
+
+    fn process_response(response: Response) -> Result<Response> {
+        if response.success {
+            Ok(response)
+        } else {
+            if let Some(body) = response.body.clone() {
+                if let Ok(error) = serde_json::from_value::<ErrorResponse>(body) {
+                    if let Some(message) = error.error {
+                        return Err(anyhow!(message.format));
+                    };
+                };
+            }
+
+            Err(anyhow!(
+                "Received error response from adapter. Response: {:?}",
+                response.clone()
+            ))
+        }
+    }
+
+    async fn receive_server_message<Stdout>(
+        reader: &mut BufReader<Stdout>,
+        buffer: &mut String,
+        log_handlers: Option<&LogHandlers>,
+    ) -> Result<Message>
+    where
+        Stdout: AsyncRead + Unpin + Send + 'static,
+    {
+        let mut content_length = None;
+        loop {
+            buffer.truncate(0);
+
+            if reader
+                .read_line(buffer)
+                .await
+                .with_context(|| "reading a message from server")?
+                == 0
+            {
+                return Err(anyhow!("debugger reader stream closed"));
+            };
+
+            if buffer == "\r\n" {
+                break;
+            }
+
+            let parts = buffer.trim().split_once(": ");
+
+            match parts {
+                Some(("Content-Length", value)) => {
+                    content_length = Some(value.parse().context("invalid content length")?);
+                }
+                _ => {}
+            }
+        }
+
+        let content_length = content_length.context("missing content length")?;
+
+        let mut content = vec![0; content_length];
+        reader
+            .read_exact(&mut content)
+            .await
+            .with_context(|| "reading after a loop")?;
+
+        let message = std::str::from_utf8(&content).context("invalid utf8 from server")?;
+
+        if let Some(log_handlers) = log_handlers {
+            for (kind, log_handler) in log_handlers.lock().iter_mut() {
+                if matches!(kind, LogKind::Rpc) {
+                    log_handler(IoKind::StdOut, &message);
+                }
+            }
+        }
+
+        Ok(serde_json::from_str::<Message>(message)?)
+    }
+
+    pub async fn shutdown(&self) -> Result<()> {
+        log::debug!("Start shutdown client");
+
+        if let Some(server_tx) = self.server_tx.lock().await.take().as_ref() {
+            server_tx.close();
+        }
+
+        let mut current_requests = self.current_requests.lock().await;
+        let mut pending_requests = self.pending_requests.lock().await;
+
+        current_requests.clear();
+        pending_requests.clear();
+
+        let _ = self.transport.kill().await.log_err();
+
+        drop(current_requests);
+        drop(pending_requests);
+
+        log::debug!("Shutdown client completed");
+
+        anyhow::Ok(())
+    }
+
+    pub fn has_adapter_logs(&self) -> bool {
+        self.transport.has_adapter_logs()
+    }
+
+    pub fn transport(&self) -> &Transport {
+        &self.transport
+    }
+
+    pub fn add_log_handler<F>(&self, f: F, kind: LogKind)
+    where
+        F: 'static + Send + FnMut(IoKind, &str),
+    {
+        let mut log_handlers = self.log_handlers.lock();
+        log_handlers.push((kind, Box::new(f)));
+    }
+}
+
+pub struct TcpTransport {
+    pub port: u16,
+    pub host: Ipv4Addr,
+    pub timeout: u64,
+    process: Mutex<Child>,
+}
+
+impl TcpTransport {
+    /// Get an open port to use with the tcp client when not supplied by debug config
+    pub async fn port(host: &TCPHost) -> Result<u16> {
+        if let Some(port) = host.port {
+            Ok(port)
+        } else {
+            Ok(TcpListener::bind(SocketAddrV4::new(host.host(), 0))
+                .await?
+                .local_addr()?
+                .port())
+        }
+    }
+
+    async fn start(binary: &DebugAdapterBinary, cx: AsyncApp) -> Result<(TransportPipe, Self)> {
+        let Some(connection_args) = binary.connection.as_ref() else {
+            return Err(anyhow!("No connection arguments provided"));
+        };
+
+        let host = connection_args.host;
+        let port = connection_args.port;
+
+        let mut command = util::command::new_smol_command(&binary.command);
+
+        if let Some(cwd) = &binary.cwd {
+            command.current_dir(cwd);
+        }
+
+        if let Some(args) = &binary.arguments {
+            command.args(args);
+        }
+
+        if let Some(envs) = &binary.envs {
+            command.envs(envs);
+        }
+
+        command
+            .stdin(Stdio::null())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .kill_on_drop(true);
+
+        let mut process = command
+            .spawn()
+            .with_context(|| "failed to start debug adapter.")?;
+
+        let address = SocketAddrV4::new(host, port);
+
+        let timeout = connection_args.timeout.unwrap_or_else(|| {
+            cx.update(|cx| DebuggerSettings::get_global(cx).timeout)
+                .unwrap_or(2000u64)
+        });
+
+        let (rx, tx) = select! {
+            _ = cx.background_executor().timer(Duration::from_millis(timeout)).fuse() => {
+                return Err(anyhow!(format!("Connection to TCP DAP timeout {}:{}", host, port)))
+            },
+            result = cx.spawn(|cx| async move {
+                loop {
+                    match TcpStream::connect(address).await {
+                        Ok(stream) => return stream.split(),
+                        Err(_) => {
+                            cx.background_executor().timer(Duration::from_millis(100)).await;
+                        }
+                    }
+                }
+            }).fuse() => result
+        };
+        log::info!(
+            "Debug adapter has connected to TCP server {}:{}",
+            host,
+            port
+        );
+        let stdout = process.stdout.take();
+        let stderr = process.stderr.take();
+
+        let this = Self {
+            port,
+            host,
+            process: Mutex::new(process),
+            timeout,
+        };
+
+        let pipe = TransportPipe::new(
+            Box::new(tx),
+            Box::new(BufReader::new(rx)),
+            stdout.map(|s| Box::new(s) as Box<dyn AsyncRead + Unpin + Send>),
+            stderr.map(|s| Box::new(s) as Box<dyn AsyncRead + Unpin + Send>),
+        );
+
+        Ok((pipe, this))
+    }
+
+    fn has_adapter_logs(&self) -> bool {
+        true
+    }
+
+    async fn kill(&self) -> Result<()> {
+        self.process.lock().await.kill()?;
+
+        Ok(())
+    }
+}
+
+pub struct StdioTransport {
+    process: Mutex<Child>,
+}
+
+impl StdioTransport {
+    async fn start(binary: &DebugAdapterBinary, _: AsyncApp) -> Result<(TransportPipe, Self)> {
+        let mut command = util::command::new_smol_command(&binary.command);
+
+        if let Some(cwd) = &binary.cwd {
+            command.current_dir(cwd);
+        }
+
+        if let Some(args) = &binary.arguments {
+            command.args(args);
+        }
+
+        if let Some(envs) = &binary.envs {
+            command.envs(envs);
+        }
+
+        command
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .kill_on_drop(true);
+
+        let mut process = command
+            .spawn()
+            .with_context(|| "failed to spawn command.")?;
+
+        let stdin = process
+            .stdin
+            .take()
+            .ok_or_else(|| anyhow!("Failed to open stdin"))?;
+        let stdout = process
+            .stdout
+            .take()
+            .ok_or_else(|| anyhow!("Failed to open stdout"))?;
+        let stderr = process
+            .stdout
+            .take()
+            .map(|io_err| Box::new(io_err) as Box<dyn AsyncRead + Unpin + Send>);
+
+        if stderr.is_none() {
+            log::error!(
+                "Failed to connect to stderr for debug adapter command {}",
+                &binary.command
+            );
+        }
+
+        log::info!("Debug adapter has connected to stdio adapter");
+
+        let process = Mutex::new(process);
+
+        Ok((
+            TransportPipe::new(
+                Box::new(stdin),
+                Box::new(BufReader::new(stdout)),
+                None,
+                stderr,
+            ),
+            Self { process },
+        ))
+    }
+
+    fn has_adapter_logs(&self) -> bool {
+        false
+    }
+
+    async fn kill(&self) -> Result<()> {
+        self.process.lock().await.kill()?;
+        Ok(())
+    }
+}
+
+#[cfg(any(test, feature = "test-support"))]
+type RequestHandler = Box<
+    dyn Send
+        + FnMut(
+            u64,
+            serde_json::Value,
+            Arc<Mutex<async_pipe::PipeWriter>>,
+        ) -> std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send>>,
+>;
+
+#[cfg(any(test, feature = "test-support"))]
+type ResponseHandler = Box<dyn Send + Fn(Response)>;
+
+#[cfg(any(test, feature = "test-support"))]
+pub struct FakeTransport {
+    // for sending fake response back from adapter side
+    request_handlers: Arc<Mutex<HashMap<&'static str, RequestHandler>>>,
+    // for reverse request responses
+    response_handlers: Arc<Mutex<HashMap<&'static str, ResponseHandler>>>,
+}
+
+#[cfg(any(test, feature = "test-support"))]
+impl FakeTransport {
+    pub async fn on_request<R: dap_types::requests::Request, F>(&self, mut handler: F)
+    where
+        F: 'static + Send + FnMut(u64, R::Arguments) -> Result<R::Response, ErrorResponse>,
+    {
+        self.request_handlers.lock().await.insert(
+            R::COMMAND,
+            Box::new(
+                move |seq, args, writer: Arc<Mutex<async_pipe::PipeWriter>>| {
+                    let response = handler(seq, serde_json::from_value(args).unwrap());
+
+                    let message = serde_json::to_string(&Message::Response(Response {
+                        seq: seq + 1,
+                        request_seq: seq,
+                        success: response.as_ref().is_ok(),
+                        command: R::COMMAND.into(),
+                        body: util::maybe!({ serde_json::to_value(response.ok()?).ok() }),
+                    }))
+                    .unwrap();
+
+                    let writer = writer.clone();
+
+                    Box::pin(async move {
+                        let mut writer = writer.lock().await;
+                        writer
+                            .write_all(TransportDelegate::build_rpc_message(message).as_bytes())
+                            .await
+                            .unwrap();
+                        writer.flush().await.unwrap();
+                    })
+                },
+            ),
+        );
+    }
+
+    pub async fn on_response<R: dap_types::requests::Request, F>(&self, handler: F)
+    where
+        F: 'static + Send + Fn(Response),
+    {
+        self.response_handlers
+            .lock()
+            .await
+            .insert(R::COMMAND, Box::new(handler));
+    }
+
+    async fn start(cx: AsyncApp) -> Result<(TransportPipe, Self)> {
+        let this = Self {
+            request_handlers: Arc::new(Mutex::new(HashMap::default())),
+            response_handlers: Arc::new(Mutex::new(HashMap::default())),
+        };
+        use dap_types::requests::{Request, RunInTerminal, StartDebugging};
+        use serde_json::json;
+
+        let (stdin_writer, stdin_reader) = async_pipe::pipe();
+        let (stdout_writer, stdout_reader) = async_pipe::pipe();
+
+        let request_handlers = this.request_handlers.clone();
+        let response_handlers = this.response_handlers.clone();
+        let stdout_writer = Arc::new(Mutex::new(stdout_writer));
+
+        cx.background_executor()
+            .spawn(async move {
+                let mut reader = BufReader::new(stdin_reader);
+                let mut buffer = String::new();
+
+                loop {
+                    let message =
+                        TransportDelegate::receive_server_message(&mut reader, &mut buffer, None)
+                            .await;
+
+                    match message {
+                        Err(error) => {
+                            break anyhow!(error);
+                        }
+                        Ok(message) => {
+                            match message {
+                                Message::Request(request) => {
+                                    // redirect reverse requests to stdout writer/reader
+                                    if request.command == RunInTerminal::COMMAND
+                                        || request.command == StartDebugging::COMMAND
+                                    {
+                                        let message =
+                                            serde_json::to_string(&Message::Request(request))
+                                                .unwrap();
+
+                                        let mut writer = stdout_writer.lock().await;
+                                        writer
+                                            .write_all(
+                                                TransportDelegate::build_rpc_message(message)
+                                                    .as_bytes(),
+                                            )
+                                            .await
+                                            .unwrap();
+                                        writer.flush().await.unwrap();
+                                    } else {
+                                        if let Some(handle) = request_handlers
+                                            .lock()
+                                            .await
+                                            .get_mut(request.command.as_str())
+                                        {
+                                            handle(
+                                                request.seq,
+                                                request.arguments.unwrap_or(json!({})),
+                                                stdout_writer.clone(),
+                                            )
+                                            .await;
+                                        } else {
+                                            log::error!(
+                                                "No request handler for {}",
+                                                request.command
+                                            );
+                                        }
+                                    }
+                                }
+                                Message::Event(event) => {
+                                    let message =
+                                        serde_json::to_string(&Message::Event(event)).unwrap();
+
+                                    let mut writer = stdout_writer.lock().await;
+                                    writer
+                                        .write_all(
+                                            TransportDelegate::build_rpc_message(message)
+                                                .as_bytes(),
+                                        )
+                                        .await
+                                        .unwrap();
+                                    writer.flush().await.unwrap();
+                                }
+                                Message::Response(response) => {
+                                    if let Some(handle) = response_handlers
+                                        .lock()
+                                        .await
+                                        .get(response.command.as_str())
+                                    {
+                                        handle(response);
+                                    } else {
+                                        log::error!("No response handler for {}", response.command);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            })
+            .detach();
+
+        Ok((
+            TransportPipe::new(Box::new(stdin_writer), Box::new(stdout_reader), None, None),
+            this,
+        ))
+    }
+
+    fn has_adapter_logs(&self) -> bool {
+        false
+    }
+
+    async fn kill(&self) -> Result<()> {
+        Ok(())
+    }
+}

crates/dap_adapters/Cargo.toml

@@ -0,0 +1,41 @@
+[package]
+name = "dap_adapters"
+version = "0.1.0"
+edition.workspace = true
+publish.workspace = true
+license = "GPL-3.0-or-later"
+
+[features]
+test-support = [
+    "dap/test-support",
+    "gpui/test-support",
+    "task/test-support",
+    "util/test-support",
+]
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/dap_adapters.rs"
+doctest = false
+
+[dependencies]
+anyhow.workspace = true
+async-trait.workspace = true
+dap.workspace = true
+gpui.workspace = true
+language.workspace = true
+paths.workspace = true
+regex.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+sysinfo.workspace = true
+task.workspace = true
+util.workspace = true
+
+[dev-dependencies]
+dap = { workspace = true, features = ["test-support"] }
+gpui = { workspace = true, features = ["test-support"] }
+task = { workspace = true, features = ["test-support"] }
+util = { workspace = true, features = ["test-support"] }

crates/dap_adapters/LICENSE-GPL

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

crates/dap_adapters/src/custom.rs

@@ -0,0 +1,79 @@
+use dap::transport::TcpTransport;
+use gpui::AsyncApp;
+use serde_json::Value;
+use std::{ffi::OsString, path::PathBuf};
+use task::DebugAdapterConfig;
+
+use crate::*;
+
+pub(crate) struct CustomDebugAdapter {
+    custom_args: CustomArgs,
+}
+
+impl CustomDebugAdapter {
+    const ADAPTER_NAME: &'static str = "custom_dap";
+
+    pub(crate) async fn new(custom_args: CustomArgs) -> Result<Self> {
+        Ok(CustomDebugAdapter { custom_args })
+    }
+}
+
+#[async_trait(?Send)]
+impl DebugAdapter for CustomDebugAdapter {
+    fn name(&self) -> DebugAdapterName {
+        DebugAdapterName(Self::ADAPTER_NAME.into())
+    }
+
+    async fn get_binary(
+        &self,
+        _: &dyn DapDelegate,
+        config: &DebugAdapterConfig,
+        _: Option<PathBuf>,
+        _: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary> {
+        let connection = if let DebugConnectionType::TCP(connection) = &self.custom_args.connection
+        {
+            Some(adapters::TcpArguments {
+                host: connection.host(),
+                port: TcpTransport::port(&connection).await?,
+                timeout: connection.timeout,
+            })
+        } else {
+            None
+        };
+        let ret = DebugAdapterBinary {
+            command: self.custom_args.command.clone(),
+            arguments: self
+                .custom_args
+                .args
+                .clone()
+                .map(|args| args.iter().map(OsString::from).collect()),
+            cwd: config.cwd.clone(),
+            envs: self.custom_args.envs.clone(),
+            connection,
+        };
+        Ok(ret)
+    }
+
+    async fn fetch_latest_adapter_version(&self, _: &dyn DapDelegate) -> Result<AdapterVersion> {
+        bail!("Custom debug adapters don't have latest versions")
+    }
+
+    async fn install_binary(&self, _: AdapterVersion, _: &dyn DapDelegate) -> Result<()> {
+        bail!("Custom debug adapters cannot be installed")
+    }
+
+    async fn get_installed_binary(
+        &self,
+        _: &dyn DapDelegate,
+        _: &DebugAdapterConfig,
+        _: Option<PathBuf>,
+        _: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary> {
+        bail!("Custom debug adapters cannot be installed")
+    }
+
+    fn request_args(&self, config: &DebugAdapterConfig) -> Value {
+        json!({"program": config.program})
+    }
+}

crates/dap_adapters/src/dap_adapters.rs

@@ -0,0 +1,49 @@
+mod custom;
+#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+mod gdb;
+mod go;
+mod javascript;
+mod lldb;
+mod php;
+mod python;
+
+use std::sync::Arc;
+
+use anyhow::{anyhow, bail, Result};
+use async_trait::async_trait;
+use custom::CustomDebugAdapter;
+use dap::adapters::{
+    self, AdapterVersion, DapDelegate, DebugAdapter, DebugAdapterBinary, DebugAdapterName,
+    GithubRepo,
+};
+#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+use gdb::GdbDebugAdapter;
+use go::GoDebugAdapter;
+use javascript::JsDebugAdapter;
+use lldb::LldbDebugAdapter;
+use php::PhpDebugAdapter;
+use python::PythonDebugAdapter;
+use serde_json::{json, Value};
+use task::{CustomArgs, DebugAdapterConfig, DebugAdapterKind, DebugConnectionType, TCPHost};
+
+pub async fn build_adapter(kind: &DebugAdapterKind) -> Result<Arc<dyn DebugAdapter>> {
+    match kind {
+        DebugAdapterKind::Custom(start_args) => {
+            Ok(Arc::new(CustomDebugAdapter::new(start_args.clone()).await?))
+        }
+        DebugAdapterKind::Python(host) => Ok(Arc::new(PythonDebugAdapter::new(host).await?)),
+        DebugAdapterKind::Php(host) => Ok(Arc::new(PhpDebugAdapter::new(host.clone()).await?)),
+        DebugAdapterKind::Javascript(host) => {
+            Ok(Arc::new(JsDebugAdapter::new(host.clone()).await?))
+        }
+        DebugAdapterKind::Lldb => Ok(Arc::new(LldbDebugAdapter::new())),
+        DebugAdapterKind::Go(host) => Ok(Arc::new(GoDebugAdapter::new(host).await?)),
+        #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+        DebugAdapterKind::Gdb => Ok(Arc::new(GdbDebugAdapter::new())),
+        #[cfg(any(test, feature = "test-support"))]
+        DebugAdapterKind::Fake => Ok(Arc::new(dap::adapters::FakeAdapter::new())),
+        #[cfg(not(any(test, feature = "test-support")))]
+        #[allow(unreachable_patterns)]
+        _ => unreachable!("Fake variant only exists with test-support feature"),
+    }
+}

crates/dap_adapters/src/gdb.rs

@@ -0,0 +1,83 @@
+use std::ffi::OsStr;
+
+use anyhow::Result;
+use async_trait::async_trait;
+use gpui::AsyncApp;
+use task::DebugAdapterConfig;
+
+use crate::*;
+
+pub(crate) struct GdbDebugAdapter {}
+
+impl GdbDebugAdapter {
+    const ADAPTER_NAME: &'static str = "gdb";
+
+    pub(crate) fn new() -> Self {
+        GdbDebugAdapter {}
+    }
+}
+
+#[async_trait(?Send)]
+impl DebugAdapter for GdbDebugAdapter {
+    fn name(&self) -> DebugAdapterName {
+        DebugAdapterName(Self::ADAPTER_NAME.into())
+    }
+
+    async fn get_binary(
+        &self,
+        delegate: &dyn DapDelegate,
+        config: &DebugAdapterConfig,
+        user_installed_path: Option<std::path::PathBuf>,
+        _: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary> {
+        let user_setting_path = user_installed_path
+            .filter(|p| p.exists())
+            .and_then(|p| p.to_str().map(|s| s.to_string()));
+
+        /* GDB implements DAP natively so just need to  */
+        let gdb_path = delegate
+            .which(OsStr::new("gdb"))
+            .and_then(|p| p.to_str().map(|s| s.to_string()))
+            .ok_or(anyhow!("Could not find gdb in path"));
+
+        if gdb_path.is_err() && user_setting_path.is_none() {
+            bail!("Could not find gdb path or it's not installed");
+        }
+
+        let gdb_path = user_setting_path.unwrap_or(gdb_path?);
+
+        Ok(DebugAdapterBinary {
+            command: gdb_path,
+            arguments: Some(vec!["-i=dap".into()]),
+            envs: None,
+            cwd: config.cwd.clone(),
+            connection: None,
+        })
+    }
+
+    async fn install_binary(
+        &self,
+        _version: AdapterVersion,
+        _delegate: &dyn DapDelegate,
+    ) -> Result<()> {
+        unimplemented!("GDB debug adapter cannot be installed by Zed (yet)")
+    }
+
+    async fn fetch_latest_adapter_version(&self, _: &dyn DapDelegate) -> Result<AdapterVersion> {
+        unimplemented!("Fetch latest GDB version not implemented (yet)")
+    }
+
+    async fn get_installed_binary(
+        &self,
+        _: &dyn DapDelegate,
+        _: &DebugAdapterConfig,
+        _: Option<std::path::PathBuf>,
+        _: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary> {
+        unimplemented!("GDB cannot be installed by Zed (yet)")
+    }
+
+    fn request_args(&self, config: &DebugAdapterConfig) -> Value {
+        json!({"program": config.program, "cwd": config.cwd})
+    }
+}

crates/dap_adapters/src/go.rs

@@ -0,0 +1,100 @@
+use dap::transport::TcpTransport;
+use gpui::AsyncApp;
+use std::{ffi::OsStr, net::Ipv4Addr, path::PathBuf};
+
+use crate::*;
+
+pub(crate) struct GoDebugAdapter {
+    port: u16,
+    host: Ipv4Addr,
+    timeout: Option<u64>,
+}
+
+impl GoDebugAdapter {
+    const ADAPTER_NAME: &'static str = "delve";
+
+    pub(crate) async fn new(host: &TCPHost) -> Result<Self> {
+        Ok(GoDebugAdapter {
+            port: TcpTransport::port(host).await?,
+            host: host.host(),
+            timeout: host.timeout,
+        })
+    }
+}
+
+#[async_trait(?Send)]
+impl DebugAdapter for GoDebugAdapter {
+    fn name(&self) -> DebugAdapterName {
+        DebugAdapterName(Self::ADAPTER_NAME.into())
+    }
+
+    async fn get_binary(
+        &self,
+        delegate: &dyn DapDelegate,
+        config: &DebugAdapterConfig,
+        user_installed_path: Option<PathBuf>,
+        cx: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary> {
+        self.get_installed_binary(delegate, config, user_installed_path, cx)
+            .await
+    }
+
+    async fn fetch_latest_adapter_version(
+        &self,
+        _delegate: &dyn DapDelegate,
+    ) -> Result<AdapterVersion> {
+        unimplemented!("This adapter is used from path for now");
+    }
+
+    async fn install_binary(
+        &self,
+        version: AdapterVersion,
+        delegate: &dyn DapDelegate,
+    ) -> Result<()> {
+        adapters::download_adapter_from_github(
+            self.name(),
+            version,
+            adapters::DownloadedFileType::Zip,
+            delegate,
+        )
+        .await?;
+        Ok(())
+    }
+
+    async fn get_installed_binary(
+        &self,
+        delegate: &dyn DapDelegate,
+        config: &DebugAdapterConfig,
+        _: Option<PathBuf>,
+        _: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary> {
+        let delve_path = delegate
+            .which(OsStr::new("dlv"))
+            .and_then(|p| p.to_str().map(|p| p.to_string()))
+            .ok_or(anyhow!("Dlv not found in path"))?;
+
+        Ok(DebugAdapterBinary {
+            command: delve_path,
+            arguments: Some(vec![
+                "dap".into(),
+                "--listen".into(),
+                format!("{}:{}", self.host, self.port).into(),
+            ]),
+            cwd: config.cwd.clone(),
+            envs: None,
+            connection: Some(adapters::TcpArguments {
+                host: self.host,
+                port: self.port,
+                timeout: self.timeout,
+            }),
+        })
+    }
+
+    fn request_args(&self, config: &DebugAdapterConfig) -> Value {
+        json!({
+            "program": config.program,
+            "cwd": config.cwd,
+            "subProcess": true,
+        })
+    }
+}

crates/dap_adapters/src/javascript.rs

@@ -0,0 +1,153 @@
+use adapters::latest_github_release;
+use dap::transport::TcpTransport;
+use gpui::AsyncApp;
+use regex::Regex;
+use std::{collections::HashMap, net::Ipv4Addr, path::PathBuf};
+use sysinfo::{Pid, Process};
+use task::DebugRequestType;
+
+use crate::*;
+
+pub(crate) struct JsDebugAdapter {
+    port: u16,
+    host: Ipv4Addr,
+    timeout: Option<u64>,
+}
+
+impl JsDebugAdapter {
+    const ADAPTER_NAME: &'static str = "vscode-js-debug";
+    const ADAPTER_PATH: &'static str = "js-debug/src/dapDebugServer.js";
+
+    pub(crate) async fn new(host: TCPHost) -> Result<Self> {
+        Ok(JsDebugAdapter {
+            host: host.host(),
+            timeout: host.timeout,
+            port: TcpTransport::port(&host).await?,
+        })
+    }
+}
+
+#[async_trait(?Send)]
+impl DebugAdapter for JsDebugAdapter {
+    fn name(&self) -> DebugAdapterName {
+        DebugAdapterName(Self::ADAPTER_NAME.into())
+    }
+
+    async fn fetch_latest_adapter_version(
+        &self,
+        delegate: &dyn DapDelegate,
+    ) -> Result<AdapterVersion> {
+        let release = latest_github_release(
+            &format!("{}/{}", "microsoft", Self::ADAPTER_NAME),
+            true,
+            false,
+            delegate.http_client(),
+        )
+        .await?;
+
+        let asset_name = format!("js-debug-dap-{}.tar.gz", release.tag_name);
+
+        Ok(AdapterVersion {
+            tag_name: release.tag_name,
+            url: release
+                .assets
+                .iter()
+                .find(|asset| asset.name == asset_name)
+                .ok_or_else(|| anyhow!("no asset found matching {:?}", asset_name))?
+                .browser_download_url
+                .clone(),
+        })
+    }
+
+    async fn get_installed_binary(
+        &self,
+        delegate: &dyn DapDelegate,
+        config: &DebugAdapterConfig,
+        user_installed_path: Option<PathBuf>,
+        _: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary> {
+        let adapter_path = if let Some(user_installed_path) = user_installed_path {
+            user_installed_path
+        } else {
+            let adapter_path = paths::debug_adapters_dir().join(self.name());
+
+            let file_name_prefix = format!("{}_", self.name());
+
+            util::fs::find_file_name_in_dir(adapter_path.as_path(), |file_name| {
+                file_name.starts_with(&file_name_prefix)
+            })
+            .await
+            .ok_or_else(|| anyhow!("Couldn't find JavaScript dap directory"))?
+        };
+
+        Ok(DebugAdapterBinary {
+            command: delegate
+                .node_runtime()
+                .binary_path()
+                .await?
+                .to_string_lossy()
+                .into_owned(),
+            arguments: Some(vec![
+                adapter_path.join(Self::ADAPTER_PATH).into(),
+                self.port.to_string().into(),
+                self.host.to_string().into(),
+            ]),
+            cwd: config.cwd.clone(),
+            envs: None,
+            connection: Some(adapters::TcpArguments {
+                host: self.host,
+                port: self.port,
+                timeout: self.timeout,
+            }),
+        })
+    }
+
+    async fn install_binary(
+        &self,
+        version: AdapterVersion,
+        delegate: &dyn DapDelegate,
+    ) -> Result<()> {
+        adapters::download_adapter_from_github(
+            self.name(),
+            version,
+            adapters::DownloadedFileType::GzipTar,
+            delegate,
+        )
+        .await?;
+
+        return Ok(());
+    }
+
+    fn request_args(&self, config: &DebugAdapterConfig) -> Value {
+        let pid = if let DebugRequestType::Attach(attach_config) = &config.request {
+            attach_config.process_id
+        } else {
+            None
+        };
+
+        json!({
+            "program": config.program,
+            "type": "pwa-node",
+            "request": match config.request {
+                DebugRequestType::Launch => "launch",
+                DebugRequestType::Attach(_) => "attach",
+            },
+            "processId": pid,
+            "cwd": config.cwd,
+        })
+    }
+
+    fn attach_processes<'a>(
+        &self,
+        processes: &'a HashMap<Pid, Process>,
+    ) -> Option<Vec<(&'a Pid, &'a Process)>> {
+        let regex = Regex::new(r"(?i)^(?:node|bun|iojs)(?:$|\b)").unwrap();
+
+        Some(
+            processes
+                .iter()
+                .filter(|(_, process)| regex.is_match(&process.name().to_string_lossy()))
+                .collect::<Vec<_>>(),
+        )
+    }
+}

crates/dap_adapters/src/lldb.rs

@@ -0,0 +1,107 @@
+use std::{collections::HashMap, ffi::OsStr, path::PathBuf};
+
+use anyhow::Result;
+use async_trait::async_trait;
+use gpui::AsyncApp;
+use sysinfo::{Pid, Process};
+use task::{DebugAdapterConfig, DebugRequestType};
+
+use crate::*;
+
+pub(crate) struct LldbDebugAdapter {}
+
+impl LldbDebugAdapter {
+    const ADAPTER_NAME: &'static str = "lldb";
+
+    pub(crate) fn new() -> Self {
+        LldbDebugAdapter {}
+    }
+}
+
+#[async_trait(?Send)]
+impl DebugAdapter for LldbDebugAdapter {
+    fn name(&self) -> DebugAdapterName {
+        DebugAdapterName(Self::ADAPTER_NAME.into())
+    }
+
+    async fn get_binary(
+        &self,
+        delegate: &dyn DapDelegate,
+        config: &DebugAdapterConfig,
+        user_installed_path: Option<PathBuf>,
+        _: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary> {
+        let lldb_dap_path = if let Some(user_installed_path) = user_installed_path {
+            user_installed_path.to_string_lossy().into()
+        } else if cfg!(target_os = "macos") {
+            util::command::new_smol_command("xcrun")
+                .args(&["-f", "lldb-dap"])
+                .output()
+                .await
+                .ok()
+                .and_then(|output| String::from_utf8(output.stdout).ok())
+                .map(|path| path.trim().to_string())
+                .ok_or(anyhow!("Failed to find lldb-dap in user's path"))?
+        } else {
+            delegate
+                .which(OsStr::new("lldb-dap"))
+                .and_then(|p| p.to_str().map(|s| s.to_string()))
+                .ok_or(anyhow!("Could not find lldb-dap in path"))?
+        };
+
+        Ok(DebugAdapterBinary {
+            command: lldb_dap_path,
+            arguments: None,
+            envs: None,
+            cwd: config.cwd.clone(),
+            connection: None,
+        })
+    }
+
+    async fn install_binary(
+        &self,
+        _version: AdapterVersion,
+        _delegate: &dyn DapDelegate,
+    ) -> Result<()> {
+        unimplemented!("LLDB debug adapter cannot be installed by Zed (yet)")
+    }
+
+    async fn fetch_latest_adapter_version(&self, _: &dyn DapDelegate) -> Result<AdapterVersion> {
+        unimplemented!("Fetch latest adapter version not implemented for lldb (yet)")
+    }
+
+    async fn get_installed_binary(
+        &self,
+        _: &dyn DapDelegate,
+        _: &DebugAdapterConfig,
+        _: Option<PathBuf>,
+        _: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary> {
+        unimplemented!("LLDB debug adapter cannot be installed by Zed (yet)")
+    }
+
+    fn request_args(&self, config: &DebugAdapterConfig) -> Value {
+        let pid = if let DebugRequestType::Attach(attach_config) = &config.request {
+            attach_config.process_id
+        } else {
+            None
+        };
+
+        json!({
+            "program": config.program,
+            "request": match config.request {
+                DebugRequestType::Launch => "launch",
+                DebugRequestType::Attach(_) => "attach",
+            },
+            "pid": pid,
+            "cwd": config.cwd,
+        })
+    }
+
+    fn attach_processes<'a>(
+        &self,
+        processes: &'a HashMap<Pid, Process>,
+    ) -> Option<Vec<(&'a Pid, &'a Process)>> {
+        Some(processes.iter().collect::<Vec<_>>())
+    }
+}

crates/dap_adapters/src/php.rs

@@ -0,0 +1,123 @@
+use adapters::latest_github_release;
+use dap::{adapters::TcpArguments, transport::TcpTransport};
+use gpui::AsyncApp;
+use std::{net::Ipv4Addr, path::PathBuf};
+
+use crate::*;
+
+pub(crate) struct PhpDebugAdapter {
+    port: u16,
+    _host: Ipv4Addr,
+    _timeout: Option<u64>,
+}
+
+impl PhpDebugAdapter {
+    const ADAPTER_NAME: &'static str = "vscode-php-debug";
+    const ADAPTER_PATH: &'static str = "extension/out/phpDebug.js";
+
+    pub(crate) async fn new(host: TCPHost) -> Result<Self> {
+        Ok(PhpDebugAdapter {
+            port: TcpTransport::port(&host).await?,
+            _host: host.host(),
+            _timeout: host.timeout,
+        })
+    }
+}
+
+#[async_trait(?Send)]
+impl DebugAdapter for PhpDebugAdapter {
+    fn name(&self) -> DebugAdapterName {
+        DebugAdapterName(Self::ADAPTER_NAME.into())
+    }
+
+    async fn fetch_latest_adapter_version(
+        &self,
+        delegate: &dyn DapDelegate,
+    ) -> Result<AdapterVersion> {
+        let release = latest_github_release(
+            &format!("{}/{}", "xdebug", Self::ADAPTER_NAME),
+            true,
+            false,
+            delegate.http_client(),
+        )
+        .await?;
+
+        let asset_name = format!("php-debug-{}.vsix", release.tag_name.replace("v", ""));
+
+        Ok(AdapterVersion {
+            tag_name: release.tag_name,
+            url: release
+                .assets
+                .iter()
+                .find(|asset| asset.name == asset_name)
+                .ok_or_else(|| anyhow!("no asset found matching {:?}", asset_name))?
+                .browser_download_url
+                .clone(),
+        })
+    }
+
+    async fn get_installed_binary(
+        &self,
+        delegate: &dyn DapDelegate,
+        config: &DebugAdapterConfig,
+        user_installed_path: Option<PathBuf>,
+        _: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary> {
+        let adapter_path = if let Some(user_installed_path) = user_installed_path {
+            user_installed_path
+        } else {
+            let adapter_path = paths::debug_adapters_dir().join(self.name());
+
+            let file_name_prefix = format!("{}_", self.name());
+
+            util::fs::find_file_name_in_dir(adapter_path.as_path(), |file_name| {
+                file_name.starts_with(&file_name_prefix)
+            })
+            .await
+            .ok_or_else(|| anyhow!("Couldn't find PHP dap directory"))?
+        };
+
+        Ok(DebugAdapterBinary {
+            command: delegate
+                .node_runtime()
+                .binary_path()
+                .await?
+                .to_string_lossy()
+                .into_owned(),
+            arguments: Some(vec![
+                adapter_path.join(Self::ADAPTER_PATH).into(),
+                format!("--server={}", self.port).into(),
+            ]),
+            connection: Some(TcpArguments {
+                port: self.port,
+                host: self._host,
+                timeout: self._timeout,
+            }),
+            cwd: config.cwd.clone(),
+            envs: None,
+        })
+    }
+
+    async fn install_binary(
+        &self,
+        version: AdapterVersion,
+        delegate: &dyn DapDelegate,
+    ) -> Result<()> {
+        adapters::download_adapter_from_github(
+            self.name(),
+            version,
+            adapters::DownloadedFileType::Vsix,
+            delegate,
+        )
+        .await?;
+
+        Ok(())
+    }
+
+    fn request_args(&self, config: &DebugAdapterConfig) -> Value {
+        json!({
+            "program": config.program,
+            "cwd": config.cwd,
+        })
+    }
+}

crates/dap_adapters/src/python.rs

@@ -0,0 +1,141 @@
+use crate::*;
+use dap::transport::TcpTransport;
+use gpui::AsyncApp;
+use std::{ffi::OsStr, net::Ipv4Addr, path::PathBuf};
+
+pub(crate) struct PythonDebugAdapter {
+    port: u16,
+    host: Ipv4Addr,
+    timeout: Option<u64>,
+}
+
+impl PythonDebugAdapter {
+    const ADAPTER_NAME: &'static str = "debugpy";
+    const ADAPTER_PATH: &'static str = "src/debugpy/adapter";
+    const LANGUAGE_NAME: &'static str = "Python";
+
+    pub(crate) async fn new(host: &TCPHost) -> Result<Self> {
+        Ok(PythonDebugAdapter {
+            port: TcpTransport::port(host).await?,
+            host: host.host(),
+            timeout: host.timeout,
+        })
+    }
+}
+
+#[async_trait(?Send)]
+impl DebugAdapter for PythonDebugAdapter {
+    fn name(&self) -> DebugAdapterName {
+        DebugAdapterName(Self::ADAPTER_NAME.into())
+    }
+
+    async fn fetch_latest_adapter_version(
+        &self,
+        delegate: &dyn DapDelegate,
+    ) -> Result<AdapterVersion> {
+        let github_repo = GithubRepo {
+            repo_name: Self::ADAPTER_NAME.into(),
+            repo_owner: "microsoft".into(),
+        };
+
+        adapters::fetch_latest_adapter_version_from_github(github_repo, delegate).await
+    }
+
+    async fn install_binary(
+        &self,
+        version: AdapterVersion,
+        delegate: &dyn DapDelegate,
+    ) -> Result<()> {
+        let version_path = adapters::download_adapter_from_github(
+            self.name(),
+            version,
+            adapters::DownloadedFileType::Zip,
+            delegate,
+        )
+        .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-")
+            })
+            .await
+        {
+            // TODO Debugger: Rename folder instead of moving all files to another folder
+            // We're doing uncessary IO work right now
+            util::fs::move_folder_files_to_folder(debugpy_dir.as_path(), version_path.as_path())
+                .await?;
+        }
+
+        Ok(())
+    }
+
+    async fn get_installed_binary(
+        &self,
+        delegate: &dyn DapDelegate,
+        config: &DebugAdapterConfig,
+        user_installed_path: Option<PathBuf>,
+        cx: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary> {
+        const BINARY_NAMES: [&str; 3] = ["python3", "python", "py"];
+
+        let debugpy_dir = if let Some(user_installed_path) = user_installed_path {
+            user_installed_path
+        } else {
+            let adapter_path = paths::debug_adapters_dir().join(self.name());
+            let file_name_prefix = format!("{}_", self.name());
+
+            util::fs::find_file_name_in_dir(adapter_path.as_path(), |file_name| {
+                file_name.starts_with(&file_name_prefix)
+            })
+            .await
+            .ok_or_else(|| anyhow!("Debugpy directory not found"))?
+        };
+
+        let toolchain = delegate
+            .toolchain_store()
+            .active_toolchain(
+                delegate.worktree_id(),
+                language::LanguageName::new(Self::LANGUAGE_NAME),
+                cx,
+            )
+            .await;
+
+        let python_path = if let Some(toolchain) = toolchain {
+            Some(toolchain.path.to_string())
+        } else {
+            BINARY_NAMES
+                .iter()
+                .filter_map(|cmd| {
+                    delegate
+                        .which(OsStr::new(cmd))
+                        .map(|path| path.to_string_lossy().to_string())
+                })
+                .find(|_| true)
+        };
+
+        Ok(DebugAdapterBinary {
+            command: python_path.ok_or(anyhow!("failed to find binary path for python"))?,
+            arguments: Some(vec![
+                debugpy_dir.join(Self::ADAPTER_PATH).into(),
+                format!("--port={}", self.port).into(),
+                format!("--host={}", self.host).into(),
+            ]),
+            connection: Some(adapters::TcpArguments {
+                host: self.host,
+                port: self.port,
+                timeout: self.timeout,
+            }),
+            cwd: config.cwd.clone(),
+            envs: None,
+        })
+    }
+
+    fn request_args(&self, config: &DebugAdapterConfig) -> Value {
+        json!({
+            "program": config.program,
+            "subProcess": true,
+            "cwd": config.cwd,
+        })
+    }
+}

crates/debugger_tools/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "debugger_tools"
+version = "0.1.0"
+edition.workspace = true
+publish.workspace = true
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/debugger_tools.rs"
+doctest = false
+
+[dependencies]
+anyhow.workspace = true
+dap.workspace = true
+editor.workspace = true
+futures.workspace = true
+gpui.workspace = true
+project.workspace = true
+serde_json.workspace = true
+settings.workspace = true
+smol.workspace = true
+util.workspace = true
+workspace.workspace = true

crates/debugger_tools/LICENSE-GPL

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

crates/debugger_tools/src/dap_log.rs

@@ -0,0 +1,834 @@
+use dap::{
+    client::SessionId,
+    debugger_settings::DebuggerSettings,
+    transport::{IoKind, LogKind},
+};
+use editor::{Editor, EditorEvent};
+use futures::{
+    channel::mpsc::{unbounded, UnboundedSender},
+    StreamExt,
+};
+use gpui::{
+    actions, div, App, AppContext, Context, Empty, Entity, EventEmitter, FocusHandle, Focusable,
+    IntoElement, ParentElement, Render, SharedString, Styled, Subscription, WeakEntity, Window,
+};
+use project::{debugger::session::Session, search::SearchQuery, Project};
+use settings::Settings as _;
+use std::{
+    borrow::Cow,
+    collections::{HashMap, VecDeque},
+    sync::Arc,
+};
+use util::maybe;
+use workspace::{
+    item::Item,
+    searchable::{SearchEvent, SearchableItem, SearchableItemHandle},
+    ui::{h_flex, Button, Clickable, ContextMenu, Label, LabelCommon, PopoverMenu},
+    ToolbarItemEvent, ToolbarItemView, Workspace,
+};
+
+struct DapLogView {
+    editor: Entity<Editor>,
+    focus_handle: FocusHandle,
+    log_store: Entity<LogStore>,
+    editor_subscriptions: Vec<Subscription>,
+    current_view: Option<(SessionId, LogKind)>,
+    project: Entity<Project>,
+    _subscriptions: Vec<Subscription>,
+}
+
+struct LogStore {
+    projects: HashMap<WeakEntity<Project>, ProjectState>,
+    debug_clients: HashMap<SessionId, DebugAdapterState>,
+    rpc_tx: UnboundedSender<(SessionId, IoKind, String)>,
+    adapter_log_tx: UnboundedSender<(SessionId, IoKind, String)>,
+}
+
+struct ProjectState {
+    _subscriptions: [gpui::Subscription; 2],
+}
+
+struct DebugAdapterState {
+    log_messages: VecDeque<String>,
+    rpc_messages: RpcMessages,
+}
+
+struct RpcMessages {
+    messages: VecDeque<String>,
+    last_message_kind: Option<MessageKind>,
+}
+
+impl RpcMessages {
+    const MESSAGE_QUEUE_LIMIT: usize = 255;
+
+    fn new() -> Self {
+        Self {
+            last_message_kind: None,
+            messages: VecDeque::with_capacity(Self::MESSAGE_QUEUE_LIMIT),
+        }
+    }
+}
+
+const SEND: &str = "// Send";
+const RECEIVE: &str = "// Receive";
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum MessageKind {
+    Send,
+    Receive,
+}
+
+impl MessageKind {
+    fn label(&self) -> &'static str {
+        match self {
+            Self::Send => SEND,
+            Self::Receive => RECEIVE,
+        }
+    }
+}
+
+impl DebugAdapterState {
+    fn new() -> Self {
+        Self {
+            log_messages: VecDeque::new(),
+            rpc_messages: RpcMessages::new(),
+        }
+    }
+}
+
+impl LogStore {
+    fn new(cx: &Context<Self>) -> Self {
+        let (rpc_tx, mut rpc_rx) = unbounded::<(SessionId, IoKind, String)>();
+        cx.spawn(|this, mut cx| async move {
+            while let Some((client_id, io_kind, message)) = rpc_rx.next().await {
+                if let Some(this) = this.upgrade() {
+                    this.update(&mut cx, |this, cx| {
+                        this.on_rpc_log(client_id, io_kind, &message, cx);
+                    })?;
+                }
+
+                smol::future::yield_now().await;
+            }
+            anyhow::Ok(())
+        })
+        .detach_and_log_err(cx);
+
+        let (adapter_log_tx, mut adapter_log_rx) = unbounded::<(SessionId, IoKind, String)>();
+        cx.spawn(|this, mut cx| async move {
+            while let Some((client_id, io_kind, message)) = adapter_log_rx.next().await {
+                if let Some(this) = this.upgrade() {
+                    this.update(&mut cx, |this, cx| {
+                        this.on_adapter_log(client_id, io_kind, &message, cx);
+                    })?;
+                }
+
+                smol::future::yield_now().await;
+            }
+            anyhow::Ok(())
+        })
+        .detach_and_log_err(cx);
+        Self {
+            rpc_tx,
+            adapter_log_tx,
+            projects: HashMap::new(),
+            debug_clients: HashMap::new(),
+        }
+    }
+
+    fn on_rpc_log(
+        &mut self,
+        client_id: SessionId,
+        io_kind: IoKind,
+        message: &str,
+        cx: &mut Context<Self>,
+    ) {
+        self.add_debug_client_message(client_id, io_kind, message.to_string(), cx);
+    }
+
+    fn on_adapter_log(
+        &mut self,
+        client_id: SessionId,
+        io_kind: IoKind,
+        message: &str,
+        cx: &mut Context<Self>,
+    ) {
+        self.add_debug_client_log(client_id, io_kind, message.to_string(), cx);
+    }
+
+    pub fn add_project(&mut self, project: &Entity<Project>, cx: &mut Context<Self>) {
+        let weak_project = project.downgrade();
+        self.projects.insert(
+            project.downgrade(),
+            ProjectState {
+                _subscriptions: [
+                    cx.observe_release(project, move |this, _, _| {
+                        this.projects.remove(&weak_project);
+                    }),
+                    cx.subscribe(project, |this, project, event, cx| match event {
+                        project::Event::DebugClientStarted(client_id) => {
+                            let session = project
+                                .read(cx)
+                                .dap_store()
+                                .read(cx)
+                                .session_by_id(client_id);
+                            if let Some(session) = session {
+                                this.add_debug_client(*client_id, session, cx);
+                            }
+                        }
+                        project::Event::DebugClientShutdown(client_id) => {
+                            this.remove_debug_client(*client_id, cx);
+                        }
+
+                        _ => {}
+                    }),
+                ],
+            },
+        );
+    }
+
+    fn get_debug_adapter_state(&mut self, id: SessionId) -> Option<&mut DebugAdapterState> {
+        self.debug_clients.get_mut(&id)
+    }
+
+    fn add_debug_client_message(
+        &mut self,
+        id: SessionId,
+        io_kind: IoKind,
+        message: String,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(debug_client_state) = self.get_debug_adapter_state(id) else {
+            return;
+        };
+
+        let kind = match io_kind {
+            IoKind::StdOut | IoKind::StdErr => MessageKind::Receive,
+            IoKind::StdIn => MessageKind::Send,
+        };
+
+        let rpc_messages = &mut debug_client_state.rpc_messages;
+        if rpc_messages.last_message_kind != Some(kind) {
+            Self::add_debug_client_entry(
+                &mut rpc_messages.messages,
+                id,
+                kind.label().to_string(),
+                LogKind::Rpc,
+                cx,
+            );
+            rpc_messages.last_message_kind = Some(kind);
+        }
+        Self::add_debug_client_entry(&mut rpc_messages.messages, id, message, LogKind::Rpc, cx);
+
+        cx.notify();
+    }
+
+    fn add_debug_client_log(
+        &mut self,
+        id: SessionId,
+        io_kind: IoKind,
+        message: String,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(debug_client_state) = self.get_debug_adapter_state(id) else {
+            return;
+        };
+
+        let message = match io_kind {
+            IoKind::StdErr => {
+                let mut message = message.clone();
+                message.insert_str(0, "stderr: ");
+                message
+            }
+            _ => message,
+        };
+
+        Self::add_debug_client_entry(
+            &mut debug_client_state.log_messages,
+            id,
+            message,
+            LogKind::Adapter,
+            cx,
+        );
+        cx.notify();
+    }
+
+    fn add_debug_client_entry(
+        log_lines: &mut VecDeque<String>,
+        id: SessionId,
+        message: String,
+        kind: LogKind,
+        cx: &mut Context<Self>,
+    ) {
+        while log_lines.len() >= RpcMessages::MESSAGE_QUEUE_LIMIT {
+            log_lines.pop_front();
+        }
+
+        let format_messages = DebuggerSettings::get_global(cx).format_dap_log_messages;
+
+        let entry = if format_messages {
+            maybe!({
+                serde_json::to_string_pretty::<serde_json::Value>(
+                    &serde_json::from_str(&message).ok()?,
+                )
+                .ok()
+            })
+            .unwrap_or(message)
+        } else {
+            message
+        };
+        log_lines.push_back(entry.clone());
+
+        cx.emit(Event::NewLogEntry { id, entry, kind });
+    }
+
+    fn add_debug_client(
+        &mut self,
+        client_id: SessionId,
+        client: Entity<Session>,
+        cx: &App,
+    ) -> Option<&mut DebugAdapterState> {
+        let client_state = self
+            .debug_clients
+            .entry(client_id)
+            .or_insert_with(DebugAdapterState::new);
+
+        let io_tx = self.rpc_tx.clone();
+
+        let client = client.read(cx).adapter_client()?;
+        client.add_log_handler(
+            move |io_kind, message| {
+                io_tx
+                    .unbounded_send((client_id, io_kind, message.to_string()))
+                    .ok();
+            },
+            LogKind::Rpc,
+        );
+
+        let log_io_tx = self.adapter_log_tx.clone();
+        client.add_log_handler(
+            move |io_kind, message| {
+                log_io_tx
+                    .unbounded_send((client_id, io_kind, message.to_string()))
+                    .ok();
+            },
+            LogKind::Adapter,
+        );
+
+        Some(client_state)
+    }
+
+    fn remove_debug_client(&mut self, client_id: SessionId, cx: &mut Context<Self>) {
+        self.debug_clients.remove(&client_id);
+        cx.notify();
+    }
+
+    fn log_messages_for_client(&mut self, client_id: SessionId) -> Option<&mut VecDeque<String>> {
+        Some(&mut self.debug_clients.get_mut(&client_id)?.log_messages)
+    }
+
+    fn rpc_messages_for_client(&mut self, client_id: SessionId) -> Option<&mut VecDeque<String>> {
+        Some(
+            &mut self
+                .debug_clients
+                .get_mut(&client_id)?
+                .rpc_messages
+                .messages,
+        )
+    }
+}
+
+pub struct DapLogToolbarItemView {
+    log_view: Option<Entity<DapLogView>>,
+}
+
+impl DapLogToolbarItemView {
+    pub fn new() -> Self {
+        Self { log_view: None }
+    }
+}
+
+impl Render for DapLogToolbarItemView {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let Some(log_view) = self.log_view.clone() else {
+            return Empty.into_any_element();
+        };
+
+        let (menu_rows, current_client_id) = log_view.update(cx, |log_view, cx| {
+            (
+                log_view.menu_items(cx).unwrap_or_default(),
+                log_view.current_view.map(|(client_id, _)| client_id),
+            )
+        });
+
+        let current_client = current_client_id.and_then(|current_client_id| {
+            menu_rows
+                .iter()
+                .find(|row| row.client_id == current_client_id)
+        });
+
+        let dap_menu: PopoverMenu<_> = PopoverMenu::new("DapLogView")
+            .anchor(gpui::Corner::TopLeft)
+            .trigger(Button::new(
+                "debug_client_menu_header",
+                current_client
+                    .map(|sub_item| {
+                        Cow::Owned(format!(
+                            "{} ({}) - {}",
+                            sub_item.client_name,
+                            sub_item.client_id.0,
+                            match sub_item.selected_entry {
+                                LogKind::Adapter => ADAPTER_LOGS,
+                                LogKind::Rpc => RPC_MESSAGES,
+                            }
+                        ))
+                    })
+                    .unwrap_or_else(|| "No adapter selected".into()),
+            ))
+            .menu(move |mut window, cx| {
+                let log_view = log_view.clone();
+                let menu_rows = menu_rows.clone();
+                ContextMenu::build(&mut window, cx, move |mut menu, window, _cx| {
+                    for row in menu_rows.into_iter() {
+                        menu = menu.custom_row(move |_window, _cx| {
+                            div()
+                                .w_full()
+                                .pl_2()
+                                .child(
+                                    Label::new(
+                                        format!("{}. {}", row.client_id.0, row.client_name,),
+                                    )
+                                    .color(workspace::ui::Color::Muted),
+                                )
+                                .into_any_element()
+                        });
+
+                        if row.has_adapter_logs {
+                            menu = menu.custom_entry(
+                                move |_window, _cx| {
+                                    div()
+                                        .w_full()
+                                        .pl_4()
+                                        .child(Label::new(ADAPTER_LOGS))
+                                        .into_any_element()
+                                },
+                                window.handler_for(&log_view, move |view, window, cx| {
+                                    view.show_log_messages_for_adapter(row.client_id, window, cx);
+                                }),
+                            );
+                        }
+
+                        menu = menu.custom_entry(
+                            move |_window, _cx| {
+                                div()
+                                    .w_full()
+                                    .pl_4()
+                                    .child(Label::new(RPC_MESSAGES))
+                                    .into_any_element()
+                            },
+                            window.handler_for(&log_view, move |view, window, cx| {
+                                view.show_rpc_trace_for_server(row.client_id, window, cx);
+                            }),
+                        );
+                    }
+
+                    menu
+                })
+                .into()
+            });
+
+        h_flex()
+            .size_full()
+            .child(dap_menu)
+            .child(
+                div()
+                    .child(
+                        Button::new("clear_log_button", "Clear").on_click(cx.listener(
+                            |this, _, window, cx| {
+                                if let Some(log_view) = this.log_view.as_ref() {
+                                    log_view.update(cx, |log_view, cx| {
+                                        log_view.editor.update(cx, |editor, cx| {
+                                            editor.set_read_only(false);
+                                            editor.clear(window, cx);
+                                            editor.set_read_only(true);
+                                        });
+                                    })
+                                }
+                            },
+                        )),
+                    )
+                    .ml_2(),
+            )
+            .into_any_element()
+    }
+}
+
+impl EventEmitter<ToolbarItemEvent> for DapLogToolbarItemView {}
+
+impl ToolbarItemView for DapLogToolbarItemView {
+    fn set_active_pane_item(
+        &mut self,
+        active_pane_item: Option<&dyn workspace::item::ItemHandle>,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> workspace::ToolbarItemLocation {
+        if let Some(item) = active_pane_item {
+            if let Some(log_view) = item.downcast::<DapLogView>() {
+                self.log_view = Some(log_view.clone());
+                return workspace::ToolbarItemLocation::PrimaryLeft;
+            }
+        }
+        self.log_view = None;
+
+        cx.notify();
+
+        workspace::ToolbarItemLocation::Hidden
+    }
+}
+
+impl DapLogView {
+    pub fn new(
+        project: Entity<Project>,
+        log_store: Entity<LogStore>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let (editor, editor_subscriptions) = Self::editor_for_logs(String::new(), window, cx);
+
+        let focus_handle = cx.focus_handle();
+
+        let events_subscriptions = cx.subscribe(&log_store, |log_view, _, event, cx| match event {
+            Event::NewLogEntry { id, entry, kind } => {
+                if log_view.current_view == Some((*id, *kind)) {
+                    log_view.editor.update(cx, |editor, cx| {
+                        editor.set_read_only(false);
+                        let last_point = editor.buffer().read(cx).len(cx);
+                        editor.edit(
+                            vec![
+                                (last_point..last_point, entry.trim()),
+                                (last_point..last_point, "\n"),
+                            ],
+                            cx,
+                        );
+                        editor.set_read_only(true);
+                    });
+                }
+            }
+        });
+
+        Self {
+            editor,
+            focus_handle,
+            project,
+            log_store,
+            editor_subscriptions,
+            current_view: None,
+            _subscriptions: vec![events_subscriptions],
+        }
+    }
+
+    fn editor_for_logs(
+        log_contents: String,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> (Entity<Editor>, Vec<Subscription>) {
+        let editor = cx.new(|cx| {
+            let mut editor = Editor::multi_line(window, cx);
+            editor.set_text(log_contents, window, cx);
+            editor.move_to_end(&editor::actions::MoveToEnd, window, cx);
+            editor.set_read_only(true);
+            editor.set_show_edit_predictions(Some(false), window, cx);
+            editor
+        });
+        let editor_subscription = cx.subscribe(
+            &editor,
+            |_, _, event: &EditorEvent, cx: &mut Context<'_, DapLogView>| cx.emit(event.clone()),
+        );
+        let search_subscription = cx.subscribe(
+            &editor,
+            |_, _, event: &SearchEvent, cx: &mut Context<'_, DapLogView>| cx.emit(event.clone()),
+        );
+        (editor, vec![editor_subscription, search_subscription])
+    }
+
+    fn menu_items(&self, cx: &App) -> Option<Vec<DapMenuItem>> {
+        let mut menu_items = self
+            .project
+            .read(cx)
+            .dap_store()
+            .read(cx)
+            .sessions()
+            .filter_map(|client| {
+                let client = client.read(cx).adapter_client()?;
+                Some(DapMenuItem {
+                    client_id: client.id(),
+                    client_name: "debygpy (hard coded)".into(), // todo(debugger) Fix this hard coded
+                    has_adapter_logs: client.has_adapter_logs(),
+                    selected_entry: self.current_view.map_or(LogKind::Adapter, |(_, kind)| kind),
+                })
+            })
+            .collect::<Vec<_>>();
+        menu_items.sort_by_key(|item| item.client_id.0);
+        Some(menu_items)
+    }
+
+    fn show_rpc_trace_for_server(
+        &mut self,
+        client_id: SessionId,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let rpc_log = self.log_store.update(cx, |log_store, _| {
+            log_store
+                .rpc_messages_for_client(client_id)
+                .map(|state| log_contents(&state))
+        });
+        if let Some(rpc_log) = rpc_log {
+            self.current_view = Some((client_id, LogKind::Rpc));
+            let (editor, editor_subscriptions) = Self::editor_for_logs(rpc_log, window, cx);
+            let language = self.project.read(cx).languages().language_for_name("JSON");
+            editor
+                .read(cx)
+                .buffer()
+                .read(cx)
+                .as_singleton()
+                .expect("log buffer should be a singleton")
+                .update(cx, |_, cx| {
+                    cx.spawn({
+                        let buffer = cx.entity();
+                        |_, mut cx| async move {
+                            let language = language.await.ok();
+                            buffer.update(&mut cx, |buffer, cx| {
+                                buffer.set_language(language, cx);
+                            })
+                        }
+                    })
+                    .detach_and_log_err(cx);
+                });
+
+            self.editor = editor;
+            self.editor_subscriptions = editor_subscriptions;
+            cx.notify();
+        }
+
+        cx.focus_self(window);
+    }
+
+    fn show_log_messages_for_adapter(
+        &mut self,
+        client_id: SessionId,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let message_log = self.log_store.update(cx, |log_store, _| {
+            log_store
+                .log_messages_for_client(client_id)
+                .map(|state| log_contents(&state))
+        });
+        if let Some(message_log) = message_log {
+            self.current_view = Some((client_id, LogKind::Adapter));
+            let (editor, editor_subscriptions) = Self::editor_for_logs(message_log, window, cx);
+            editor
+                .read(cx)
+                .buffer()
+                .read(cx)
+                .as_singleton()
+                .expect("log buffer should be a singleton");
+
+            self.editor = editor;
+            self.editor_subscriptions = editor_subscriptions;
+            cx.notify();
+        }
+
+        cx.focus_self(window);
+    }
+}
+
+fn log_contents(lines: &VecDeque<String>) -> String {
+    let (a, b) = lines.as_slices();
+    let a = a.iter().map(move |v| v.as_ref());
+    let b = b.iter().map(move |v| v.as_ref());
+    a.chain(b).fold(String::new(), |mut acc, el| {
+        acc.push_str(el);
+        acc.push('\n');
+        acc
+    })
+}
+
+#[derive(Clone, PartialEq)]
+pub(crate) struct DapMenuItem {
+    pub client_id: SessionId,
+    pub client_name: String,
+    pub has_adapter_logs: bool,
+    pub selected_entry: LogKind,
+}
+
+const ADAPTER_LOGS: &str = "Adapter Logs";
+const RPC_MESSAGES: &str = "RPC Messages";
+
+impl Render for DapLogView {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        self.editor.update(cx, |editor, cx| {
+            editor.render(window, cx).into_any_element()
+        })
+    }
+}
+
+actions!(debug, [OpenDebuggerAdapterLogs]);
+
+pub fn init(cx: &mut App) {
+    let log_store = cx.new(|cx| LogStore::new(cx));
+
+    cx.observe_new(move |workspace: &mut Workspace, window, cx| {
+        let Some(_window) = window else {
+            return;
+        };
+
+        let project = workspace.project();
+        if project.read(cx).is_local() {
+            log_store.update(cx, |store, cx| {
+                store.add_project(project, cx);
+            });
+        }
+
+        let log_store = log_store.clone();
+        workspace.register_action(move |workspace, _: &OpenDebuggerAdapterLogs, window, cx| {
+            let project = workspace.project().read(cx);
+            if project.is_local() {
+                workspace.add_item_to_active_pane(
+                    Box::new(cx.new(|cx| {
+                        DapLogView::new(workspace.project().clone(), log_store.clone(), window, cx)
+                    })),
+                    None,
+                    true,
+                    window,
+                    cx,
+                );
+            }
+        });
+    })
+    .detach();
+}
+
+impl Item for DapLogView {
+    type Event = EditorEvent;
+
+    fn to_item_events(event: &Self::Event, f: impl FnMut(workspace::item::ItemEvent)) {
+        Editor::to_item_events(event, f)
+    }
+
+    fn tab_content_text(&self, _window: &Window, _cx: &App) -> Option<SharedString> {
+        Some("DAP Logs".into())
+    }
+
+    fn telemetry_event_text(&self) -> Option<&'static str> {
+        None
+    }
+
+    fn as_searchable(&self, handle: &Entity<Self>) -> Option<Box<dyn SearchableItemHandle>> {
+        Some(Box::new(handle.clone()))
+    }
+}
+
+impl SearchableItem for DapLogView {
+    type Match = <Editor as SearchableItem>::Match;
+
+    fn clear_matches(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        self.editor.update(cx, |e, cx| e.clear_matches(window, cx))
+    }
+
+    fn update_matches(
+        &mut self,
+        matches: &[Self::Match],
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.editor
+            .update(cx, |e, cx| e.update_matches(matches, window, cx))
+    }
+
+    fn query_suggestion(&mut self, window: &mut Window, cx: &mut Context<Self>) -> String {
+        self.editor
+            .update(cx, |e, cx| e.query_suggestion(window, cx))
+    }
+
+    fn activate_match(
+        &mut self,
+        index: usize,
+        matches: &[Self::Match],
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.editor
+            .update(cx, |e, cx| e.activate_match(index, matches, window, cx))
+    }
+
+    fn select_matches(
+        &mut self,
+        matches: &[Self::Match],
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.editor
+            .update(cx, |e, cx| e.select_matches(matches, window, cx))
+    }
+
+    fn find_matches(
+        &mut self,
+        query: Arc<project::search::SearchQuery>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> gpui::Task<Vec<Self::Match>> {
+        self.editor
+            .update(cx, |e, cx| e.find_matches(query, window, cx))
+    }
+
+    fn replace(
+        &mut self,
+        _: &Self::Match,
+        _: &SearchQuery,
+        _window: &mut Window,
+        _: &mut Context<Self>,
+    ) {
+        // Since DAP Log is read-only, it doesn't make sense to support replace operation.
+    }
+
+    fn supported_options(&self) -> workspace::searchable::SearchOptions {
+        workspace::searchable::SearchOptions {
+            case: true,
+            word: true,
+            regex: true,
+            find_in_results: true,
+            // DAP log is read-only.
+            replacement: false,
+            selection: false,
+        }
+    }
+    fn active_match_index(
+        &mut self,
+        matches: &[Self::Match],
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Option<usize> {
+        self.editor
+            .update(cx, |e, cx| e.active_match_index(matches, window, cx))
+    }
+}
+
+impl Focusable for DapLogView {
+    fn focus_handle(&self, _cx: &App) -> FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+pub enum Event {
+    NewLogEntry {
+        id: SessionId,
+        entry: String,
+        kind: LogKind,
+    },
+}
+
+impl EventEmitter<Event> for LogStore {}
+impl EventEmitter<Event> for DapLogView {}
+impl EventEmitter<EditorEvent> for DapLogView {}
+impl EventEmitter<SearchEvent> for DapLogView {}

crates/debugger_tools/src/debugger_tools.rs

@@ -0,0 +1,8 @@
+mod dap_log;
+pub use dap_log::*;
+
+use gpui::App;
+
+pub fn init(cx: &mut App) {
+    dap_log::init(cx);
+}

crates/debugger_ui/Cargo.toml

@@ -0,0 +1,59 @@
+[package]
+name = "debugger_ui"
+version = "0.1.0"
+edition.workspace = true
+publish.workspace = true
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[features]
+test-support = [
+    "dap/test-support",
+    "editor/test-support",
+    "gpui/test-support",
+    "project/test-support",
+    "util/test-support",
+    "workspace/test-support",
+]
+
+[dependencies]
+anyhow.workspace = true
+client.workspace = true
+collections.workspace = true
+command_palette_hooks.workspace = true
+dap.workspace = true
+editor.workspace = true
+feature_flags.workspace = true
+fuzzy.workspace = true
+gpui.workspace = true
+language.workspace = true
+log.workspace = true
+menu.workspace = true
+picker.workspace = true
+pretty_assertions.workspace = true
+project.workspace = true
+rpc.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+settings.workspace = true
+sum_tree.workspace = true
+sysinfo.workspace = true
+task.workspace = true
+tasks_ui.workspace = true
+terminal_view.workspace = true
+theme.workspace = true
+ui.workspace = true
+util.workspace = true
+workspace.workspace = true
+
+[dev-dependencies]
+dap = { workspace = true, features = ["test-support"] }
+editor = { workspace = true, features = ["test-support"] }
+env_logger.workspace = true
+gpui = { workspace = true, features = ["test-support"] }
+project = { workspace = true, features = ["test-support"] }
+unindent.workspace = true
+util = { workspace = true, features = ["test-support"] }
+workspace = { workspace = true, features = ["test-support"] }

crates/debugger_ui/LICENSE-GPL

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

crates/debugger_ui/src/attach_modal.rs

@@ -0,0 +1,304 @@
+use dap::client::SessionId;
+use fuzzy::{StringMatch, StringMatchCandidate};
+use gpui::Subscription;
+use gpui::{DismissEvent, Entity, EventEmitter, Focusable, Render};
+use picker::{Picker, PickerDelegate};
+use project::debugger::dap_store::DapStore;
+use std::sync::Arc;
+use sysinfo::System;
+use ui::{prelude::*, Context, Tooltip};
+use ui::{ListItem, ListItemSpacing};
+use workspace::ModalView;
+
+#[derive(Debug, Clone)]
+struct _Candidate {
+    pid: u32,
+    name: String,
+    command: Vec<String>,
+}
+
+pub(crate) struct _AttachModalDelegate {
+    selected_index: usize,
+    matches: Vec<StringMatch>,
+    session_id: SessionId,
+    placeholder_text: Arc<str>,
+    dap_store: Entity<DapStore>,
+    client_id: SessionId,
+    candidates: Option<Vec<_Candidate>>,
+}
+
+impl _AttachModalDelegate {
+    pub fn _new(session_id: SessionId, client_id: SessionId, dap_store: Entity<DapStore>) -> Self {
+        Self {
+            client_id,
+            dap_store,
+            session_id,
+            candidates: None,
+            selected_index: 0,
+            matches: Vec::default(),
+            placeholder_text: Arc::from("Select the process you want to attach the debugger to"),
+        }
+    }
+}
+
+pub(crate) struct _AttachModal {
+    _subscription: Subscription,
+    pub(crate) picker: Entity<Picker<_AttachModalDelegate>>,
+}
+
+impl _AttachModal {
+    pub fn _new(
+        session_id: &SessionId,
+        client_id: SessionId,
+        dap_store: Entity<DapStore>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let picker = cx.new(|cx| {
+            Picker::uniform_list(
+                _AttachModalDelegate::_new(*session_id, client_id, dap_store),
+                window,
+                cx,
+            )
+        });
+        let _subscription = cx.subscribe(&picker, |_, _, _, cx| {
+            cx.emit(DismissEvent);
+        });
+        Self {
+            picker,
+            _subscription,
+        }
+    }
+}
+
+impl Render for _AttachModal {
+    fn render(&mut self, _window: &mut Window, _: &mut Context<Self>) -> impl ui::IntoElement {
+        v_flex()
+            .key_context("AttachModal")
+            .w(rems(34.))
+            .child(self.picker.clone())
+    }
+}
+
+impl EventEmitter<DismissEvent> for _AttachModal {}
+
+impl Focusable for _AttachModal {
+    fn focus_handle(&self, cx: &App) -> gpui::FocusHandle {
+        self.picker.read(cx).focus_handle(cx)
+    }
+}
+
+impl ModalView for _AttachModal {}
+
+impl PickerDelegate for _AttachModalDelegate {
+    type ListItem = ListItem;
+
+    fn match_count(&self) -> usize {
+        self.matches.len()
+    }
+
+    fn selected_index(&self) -> usize {
+        self.selected_index
+    }
+
+    fn set_selected_index(
+        &mut self,
+        ix: usize,
+        _window: &mut Window,
+        _: &mut Context<Picker<Self>>,
+    ) {
+        self.selected_index = ix;
+    }
+
+    fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> std::sync::Arc<str> {
+        self.placeholder_text.clone()
+    }
+
+    fn update_matches(
+        &mut self,
+        query: String,
+        _window: &mut Window,
+        cx: &mut Context<Picker<Self>>,
+    ) -> gpui::Task<()> {
+        cx.spawn(|this, mut cx| async move {
+            let Some(processes) = this
+                .update(&mut cx, |this, cx| {
+                    if let Some(processes) = this.delegate.candidates.clone() {
+                        processes
+                    } else {
+                        let Some(_client) = this.delegate.dap_store.update(cx, |store, cx| {
+                            store
+                                .session_by_id(&this.delegate.client_id)
+                                .and_then(|client| client.read(cx).adapter_client())
+                        }) else {
+                            return Vec::new();
+                        };
+
+                        let _system = System::new_all();
+
+                        todo!("client.adapter().attach_processes(&system.processes())");
+                        // let processes: Vec<(&sysinfo::Pid, &sysinfo::Process)> = vec![];
+
+                        // let processes = processes
+                        //     .into_iter()
+                        //     .map(|(pid, process)| _Candidate {
+                        //         pid: pid.as_u32(),
+                        //         name: process.name().to_string_lossy().into_owned(),
+                        //         command: process
+                        //             .cmd()
+                        //             .iter()
+                        //             .map(|s| s.to_string_lossy().to_string())
+                        //             .collect::<Vec<_>>(),
+                        //     })
+                        //     .collect::<Vec<_Candidate>>();
+
+                        // let _ = this.delegate.candidates.insert(processes.clone());
+
+                        // processes
+                    }
+                })
+                .ok()
+            else {
+                return;
+            };
+
+            let matches = fuzzy::match_strings(
+                &processes
+                    .iter()
+                    .enumerate()
+                    .map(|(id, candidate)| {
+                        StringMatchCandidate::new(
+                            id,
+                            format!(
+                                "{} {} {}",
+                                candidate.command.join(" "),
+                                candidate.pid,
+                                candidate.name
+                            )
+                            .as_str(),
+                        )
+                    })
+                    .collect::<Vec<_>>(),
+                &query,
+                true,
+                100,
+                &Default::default(),
+                cx.background_executor().clone(),
+            )
+            .await;
+
+            this.update(&mut cx, |this, _| {
+                let delegate = &mut this.delegate;
+
+                delegate.matches = matches;
+                delegate.candidates = Some(processes);
+
+                if delegate.matches.is_empty() {
+                    delegate.selected_index = 0;
+                } else {
+                    delegate.selected_index =
+                        delegate.selected_index.min(delegate.matches.len() - 1);
+                }
+            })
+            .ok();
+        })
+    }
+
+    fn confirm(&mut self, _: bool, _window: &mut Window, cx: &mut Context<Picker<Self>>) {
+        let candidate = self
+            .matches
+            .get(self.selected_index())
+            .and_then(|current_match| {
+                let ix = current_match.candidate_id;
+                self.candidates.as_ref().map(|candidates| &candidates[ix])
+            });
+        let Some(_candidate) = candidate else {
+            return cx.emit(DismissEvent);
+        };
+
+        unimplemented!(
+            r#"self.dap_store.update(cx, |store, cx| {{
+            store
+                .attach(self.client_id, candidate.pid, cx)
+                .detach_and_log_err(cx);
+        }})"#
+        );
+
+        // cx.emit(DismissEvent);
+    }
+
+    fn dismissed(&mut self, _window: &mut Window, cx: &mut Context<Picker<Self>>) {
+        self.selected_index = 0;
+        self.candidates.take();
+
+        self.dap_store.update(cx, |store, cx| {
+            store.shutdown_session(&self.session_id, cx).detach();
+        });
+
+        cx.emit(DismissEvent);
+    }
+
+    fn render_match(
+        &self,
+        ix: usize,
+        selected: bool,
+        _window: &mut Window,
+        _: &mut Context<Picker<Self>>,
+    ) -> Option<Self::ListItem> {
+        let candidates = self.candidates.as_ref()?;
+        let hit = &self.matches[ix];
+        let candidate = &candidates.get(hit.candidate_id)?;
+
+        Some(
+            ListItem::new(SharedString::from(format!("process-entry-{ix}")))
+                .inset(true)
+                .spacing(ListItemSpacing::Sparse)
+                .toggle_state(selected)
+                .child(
+                    v_flex()
+                        .items_start()
+                        .child(Label::new(format!("{} {}", candidate.name, candidate.pid)))
+                        .child(
+                            div()
+                                .id(SharedString::from(format!("process-entry-{ix}-command")))
+                                .tooltip(Tooltip::text(
+                                    candidate
+                                        .command
+                                        .clone()
+                                        .into_iter()
+                                        .collect::<Vec<_>>()
+                                        .join(" "),
+                                ))
+                                .child(
+                                    Label::new(format!(
+                                        "{} {}",
+                                        candidate.name,
+                                        candidate
+                                            .command
+                                            .clone()
+                                            .into_iter()
+                                            .skip(1)
+                                            .collect::<Vec<_>>()
+                                            .join(" ")
+                                    ))
+                                    .size(LabelSize::Small)
+                                    .color(Color::Muted),
+                                ),
+                        ),
+                ),
+        )
+    }
+}
+
+#[allow(dead_code)]
+#[cfg(any(test, feature = "test-support"))]
+pub(crate) fn procss_names(modal: &_AttachModal, cx: &mut Context<_AttachModal>) -> Vec<String> {
+    modal.picker.update(cx, |picker, _| {
+        picker
+            .delegate
+            .matches
+            .iter()
+            .map(|hit| hit.string.clone())
+            .collect::<Vec<_>>()
+    })
+}

crates/debugger_ui/src/debugger_panel.rs

@@ -0,0 +1,398 @@
+use crate::session::DebugSession;
+use anyhow::Result;
+use command_palette_hooks::CommandPaletteFilter;
+use dap::{
+    client::SessionId, debugger_settings::DebuggerSettings, ContinuedEvent, LoadedSourceEvent,
+    ModuleEvent, OutputEvent, StoppedEvent, ThreadEvent,
+};
+use gpui::{
+    actions, Action, App, AsyncWindowContext, Context, Entity, EventEmitter, FocusHandle,
+    Focusable, Subscription, Task, WeakEntity,
+};
+use project::{
+    debugger::dap_store::{self, DapStore},
+    Project,
+};
+use rpc::proto::{self};
+use settings::Settings;
+use std::any::TypeId;
+use ui::prelude::*;
+use workspace::{
+    dock::{DockPosition, Panel, PanelEvent},
+    pane, Continue, Disconnect, Pane, Pause, Restart, StepBack, StepInto, StepOut, StepOver, Stop,
+    ToggleIgnoreBreakpoints, Workspace,
+};
+
+pub enum DebugPanelEvent {
+    Exited(SessionId),
+    Terminated(SessionId),
+    Stopped {
+        client_id: SessionId,
+        event: StoppedEvent,
+        go_to_stack_frame: bool,
+    },
+    Thread((SessionId, ThreadEvent)),
+    Continued((SessionId, ContinuedEvent)),
+    Output((SessionId, OutputEvent)),
+    Module((SessionId, ModuleEvent)),
+    LoadedSource((SessionId, LoadedSourceEvent)),
+    ClientShutdown(SessionId),
+    CapabilitiesChanged(SessionId),
+}
+
+actions!(debug_panel, [ToggleFocus]);
+pub struct DebugPanel {
+    size: Pixels,
+    pane: Entity<Pane>,
+    project: WeakEntity<Project>,
+    workspace: WeakEntity<Workspace>,
+    _subscriptions: Vec<Subscription>,
+}
+
+impl DebugPanel {
+    pub fn new(
+        workspace: &Workspace,
+        window: &mut Window,
+        cx: &mut Context<Workspace>,
+    ) -> Entity<Self> {
+        cx.new(|cx| {
+            let project = workspace.project().clone();
+            let dap_store = project.read(cx).dap_store();
+            let weak_workspace = workspace.weak_handle();
+            let pane = cx.new(|cx| {
+                let mut pane = Pane::new(
+                    workspace.weak_handle(),
+                    workspace.project().clone(),
+                    Default::default(),
+                    None,
+                    gpui::NoAction.boxed_clone(),
+                    window,
+                    cx,
+                );
+                pane.set_can_split(None);
+                pane.set_can_navigate(true, cx);
+                pane.display_nav_history_buttons(None);
+                pane.set_should_display_tab_bar(|_window, _cx| true);
+                pane.set_close_pane_if_empty(true, cx);
+                pane.set_render_tab_bar_buttons(cx, {
+                    let project = project.clone();
+                    let weak_workspace = weak_workspace.clone();
+                    move |_, _, cx| {
+                        let project = project.clone();
+                        let weak_workspace = weak_workspace.clone();
+                        (
+                            None,
+                            Some(
+                                h_flex()
+                                    .child(
+                                        IconButton::new("new-debug-session", IconName::Plus)
+                                            .icon_size(IconSize::Small)
+                                            .on_click(cx.listener(move |pane, _, window, cx| {
+                                                pane.add_item(
+                                                    Box::new(DebugSession::inert(
+                                                        project.clone(),
+                                                        weak_workspace.clone(),
+                                                        window,
+                                                        cx,
+                                                    )),
+                                                    false,
+                                                    false,
+                                                    None,
+                                                    window,
+                                                    cx,
+                                                );
+                                            })),
+                                    )
+                                    .into_any_element(),
+                            ),
+                        )
+                    }
+                });
+                pane.add_item(
+                    Box::new(DebugSession::inert(
+                        project.clone(),
+                        weak_workspace.clone(),
+                        window,
+                        cx,
+                    )),
+                    false,
+                    false,
+                    None,
+                    window,
+                    cx,
+                );
+                pane
+            });
+
+            let _subscriptions = vec![
+                cx.observe(&pane, |_, _, cx| cx.notify()),
+                cx.subscribe_in(&pane, window, Self::handle_pane_event),
+                cx.subscribe_in(&dap_store, window, Self::handle_dap_store_event),
+            ];
+
+            let debug_panel = Self {
+                pane,
+                size: px(300.),
+                _subscriptions,
+                project: project.downgrade(),
+                workspace: workspace.weak_handle(),
+            };
+
+            debug_panel
+        })
+    }
+
+    pub fn load(
+        workspace: WeakEntity<Workspace>,
+        cx: AsyncWindowContext,
+    ) -> Task<Result<Entity<Self>>> {
+        cx.spawn(|mut cx| async move {
+            workspace.update_in(&mut cx, |workspace, window, cx| {
+                let debug_panel = DebugPanel::new(workspace, window, cx);
+
+                cx.observe(&debug_panel, |_, debug_panel, cx| {
+                    let (has_active_session, support_step_back) =
+                        debug_panel.update(cx, |this, cx| {
+                            this.active_debug_panel_item(cx)
+                                .map(|_item| (true, false))
+                                .unwrap_or((false, false))
+                        });
+
+                    let filter = CommandPaletteFilter::global_mut(cx);
+                    let debugger_action_types = [
+                        TypeId::of::<Continue>(),
+                        TypeId::of::<StepOver>(),
+                        TypeId::of::<StepInto>(),
+                        TypeId::of::<StepOut>(),
+                        TypeId::of::<Stop>(),
+                        TypeId::of::<Disconnect>(),
+                        TypeId::of::<Pause>(),
+                        TypeId::of::<Restart>(),
+                        TypeId::of::<ToggleIgnoreBreakpoints>(),
+                    ];
+
+                    let step_back_action_type = [TypeId::of::<StepBack>()];
+
+                    if has_active_session {
+                        filter.show_action_types(debugger_action_types.iter());
+
+                        if support_step_back {
+                            filter.show_action_types(step_back_action_type.iter());
+                        } else {
+                            filter.hide_action_types(&step_back_action_type);
+                        }
+                    } else {
+                        // show only the `debug: start`
+                        filter.hide_action_types(&debugger_action_types);
+                        filter.hide_action_types(&step_back_action_type);
+                    }
+                })
+                .detach();
+
+                debug_panel
+            })
+        })
+    }
+
+    #[cfg(any(test, feature = "test-support"))]
+    pub fn message_queue(&self) -> &HashMap<SessionId, VecDeque<OutputEvent>> {
+        // &self.message_queue
+        unimplemented!("Should chekc session for console messagse")
+    }
+
+    #[cfg(any(test, feature = "test-support"))]
+    pub fn dap_store(&self) -> Entity<DapStore> {
+        self.dap_store.clone()
+    }
+
+    pub fn active_debug_panel_item(&self, cx: &Context<Self>) -> Option<Entity<DebugSession>> {
+        self.pane
+            .read(cx)
+            .active_item()
+            .and_then(|panel| panel.downcast::<DebugSession>())
+    }
+
+    pub fn debug_panel_items_by_client(
+        &self,
+        client_id: &SessionId,
+        cx: &Context<Self>,
+    ) -> Vec<Entity<DebugSession>> {
+        self.pane
+            .read(cx)
+            .items()
+            .filter_map(|item| item.downcast::<DebugSession>())
+            .filter(|item| item.read(cx).session_id(cx) == Some(*client_id))
+            .map(|item| item.clone())
+            .collect()
+    }
+
+    pub fn debug_panel_item_by_client(
+        &self,
+        client_id: SessionId,
+        cx: &mut Context<Self>,
+    ) -> Option<Entity<DebugSession>> {
+        self.pane
+            .read(cx)
+            .items()
+            .filter_map(|item| item.downcast::<DebugSession>())
+            .find(|item| {
+                let item = item.read(cx);
+
+                item.session_id(cx) == Some(client_id)
+            })
+    }
+
+    fn handle_dap_store_event(
+        &mut self,
+        dap_store: &Entity<DapStore>,
+        event: &dap_store::DapStoreEvent,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        match event {
+            dap_store::DapStoreEvent::DebugClientStarted(session_id) => {
+                let Some(session) = dap_store.read(cx).session_by_id(session_id) else {
+                    return log::error!("Couldn't get session with id: {session_id:?} from DebugClientStarted event");
+                };
+
+                let Some(project) = self.project.upgrade() else {
+                    return log::error!("Debug Panel out lived it's weak reference to Project");
+                };
+
+                let session_item =
+                    DebugSession::running(project, self.workspace.clone(), session, window, cx);
+
+                self.pane.update(cx, |pane, cx| {
+                    pane.add_item(Box::new(session_item), true, true, None, window, cx);
+                    window.focus(&pane.focus_handle(cx));
+                    cx.notify();
+                });
+            }
+            _ => {}
+        }
+    }
+
+    fn handle_pane_event(
+        &mut self,
+        _: &Entity<Pane>,
+        event: &pane::Event,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        match event {
+            pane::Event::Remove { .. } => cx.emit(PanelEvent::Close),
+            pane::Event::ZoomIn => cx.emit(PanelEvent::ZoomIn),
+            pane::Event::ZoomOut => cx.emit(PanelEvent::ZoomOut),
+            pane::Event::AddItem { item } => {
+                self.workspace
+                    .update(cx, |workspace, cx| {
+                        item.added_to_pane(workspace, self.pane.clone(), window, cx)
+                    })
+                    .ok();
+            }
+            _ => {}
+        }
+    }
+}
+
+impl EventEmitter<PanelEvent> for DebugPanel {}
+impl EventEmitter<DebugPanelEvent> for DebugPanel {}
+impl EventEmitter<project::Event> for DebugPanel {}
+
+impl Focusable for DebugPanel {
+    fn focus_handle(&self, cx: &App) -> FocusHandle {
+        self.pane.focus_handle(cx)
+    }
+}
+
+impl Panel for DebugPanel {
+    fn pane(&self) -> Option<Entity<Pane>> {
+        Some(self.pane.clone())
+    }
+
+    fn persistent_name() -> &'static str {
+        "DebugPanel"
+    }
+
+    fn position(&self, _window: &Window, _cx: &App) -> DockPosition {
+        DockPosition::Bottom
+    }
+
+    fn position_is_valid(&self, position: DockPosition) -> bool {
+        position == DockPosition::Bottom
+    }
+
+    fn set_position(
+        &mut self,
+        _position: DockPosition,
+        _window: &mut Window,
+        _cx: &mut Context<Self>,
+    ) {
+    }
+
+    fn size(&self, _window: &Window, _cx: &App) -> Pixels {
+        self.size
+    }
+
+    fn set_size(&mut self, size: Option<Pixels>, _window: &mut Window, _cx: &mut Context<Self>) {
+        self.size = size.unwrap();
+    }
+
+    fn remote_id() -> Option<proto::PanelId> {
+        Some(proto::PanelId::DebugPanel)
+    }
+
+    fn icon(&self, _window: &Window, _cx: &App) -> Option<IconName> {
+        Some(IconName::Debug)
+    }
+
+    fn icon_tooltip(&self, _window: &Window, cx: &App) -> Option<&'static str> {
+        if DebuggerSettings::get_global(cx).button {
+            Some("Debug Panel")
+        } else {
+            None
+        }
+    }
+
+    fn toggle_action(&self) -> Box<dyn Action> {
+        Box::new(ToggleFocus)
+    }
+
+    fn activation_priority(&self) -> u32 {
+        9
+    }
+    fn set_active(&mut self, active: bool, window: &mut Window, cx: &mut Context<Self>) {
+        if active && self.pane.read(cx).items_len() == 0 {
+            let Some(project) = self.project.clone().upgrade() else {
+                return;
+            };
+            // todo: We need to revisit it when we start adding stopped items to pane (as that'll cause us to add two items).
+            self.pane.update(cx, |this, cx| {
+                this.add_item(
+                    Box::new(DebugSession::inert(
+                        project,
+                        self.workspace.clone(),
+                        window,
+                        cx,
+                    )),
+                    false,
+                    false,
+                    None,
+                    window,
+                    cx,
+                );
+            });
+        }
+    }
+}
+
+impl Render for DebugPanel {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        v_flex()
+            .key_context("DebugPanel")
+            .track_focus(&self.focus_handle(cx))
+            .size_full()
+            .child(self.pane.clone())
+            .into_any()
+    }
+}