Hack in authentication

Co-authored-by: Mikayla Maki <mikayla.c.maki@gmail.com>

.github/workflows/ci.yml

@@ -30,6 +30,7 @@ jobs:
       run_tests: ${{ steps.filter.outputs.run_tests }}
       run_license: ${{ steps.filter.outputs.run_license }}
       run_docs: ${{ steps.filter.outputs.run_docs }}
+      run_nix: ${{ steps.filter.outputs.run_nix }}
     runs-on:
       - ubuntu-latest
     steps:
@@ -69,6 +70,12 @@ jobs:
           else
             echo "run_license=false" >> $GITHUB_OUTPUT
           fi
+          NIX_REGEX='^(nix/|flake\.|Cargo\.|rust-toolchain.toml|\.cargo/config.toml)'
+          if [[ $(git diff --name-only $COMPARE_REV ${{ github.sha }} | grep "$NIX_REGEX") ]]; then
+            echo "run_nix=true" >> $GITHUB_OUTPUT
+          else
+            echo "run_nix=false" >> $GITHUB_OUTPUT
+          fi
 
   migration_checks:
     name: Check Postgres and Protobuf migrations, mergability
@@ -746,7 +753,10 @@ jobs:
   nix-build:
     name: Build with Nix
     uses: ./.github/workflows/nix.yml
-    if: github.repository_owner == 'zed-industries' && contains(github.event.pull_request.labels.*.name, 'run-nix')
+    needs: [job_spec]
+    if: github.repository_owner == 'zed-industries' &&
+      (contains(github.event.pull_request.labels.*.name, 'run-nix') ||
+      needs.job_spec.outputs.run_nix == 'true')
     secrets: inherit
     with:
       flake-output: debug

Cargo.lock

@@ -2,6 +2,38 @@
 # It is not intended for manual editing.
 version = 4
 
+[[package]]
+name = "acp"
+version = "0.1.0"
+dependencies = [
+ "agentic-coding-protocol",
+ "anyhow",
+ "async-trait",
+ "base64 0.22.1",
+ "buffer_diff",
+ "chrono",
+ "collections",
+ "editor",
+ "env_logger 0.11.8",
+ "futures 0.3.31",
+ "gpui",
+ "language",
+ "log",
+ "markdown",
+ "parking_lot",
+ "project",
+ "proto",
+ "serde_json",
+ "settings",
+ "smol",
+ "theme",
+ "ui",
+ "util",
+ "uuid",
+ "workspace-hack",
+ "zed_actions",
+]
+
 [[package]]
 name = "activity_indicator"
 version = "0.1.0"
@@ -107,39 +139,6 @@ dependencies = [
  "zstd",
 ]
 
-[[package]]
-name = "agent2"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "assistant_tool",
- "assistant_tools",
- "chrono",
- "client",
- "collections",
- "ctor",
- "env_logger 0.11.8",
- "fs",
- "futures 0.3.31",
- "gpui",
- "gpui_tokio",
- "handlebars 4.5.0",
- "language_model",
- "language_models",
- "parking_lot",
- "project",
- "reqwest_client",
- "rust-embed",
- "schemars",
- "serde",
- "serde_json",
- "settings",
- "smol",
- "thiserror 2.0.12",
- "util",
- "worktree",
-]
-
 [[package]]
 name = "agent_settings"
 version = "0.1.0"
@@ -163,6 +162,7 @@ dependencies = [
 name = "agent_ui"
 version = "0.1.0"
 dependencies = [
+ "acp",
  "agent",
  "agent_settings",
  "anyhow",
@@ -245,6 +245,21 @@ dependencies = [
  "zed_llm_client",
 ]
 
+[[package]]
+name = "agentic-coding-protocol"
+version = "0.0.1"
+dependencies = [
+ "anyhow",
+ "async-trait",
+ "chrono",
+ "futures 0.3.31",
+ "log",
+ "parking_lot",
+ "schemars",
+ "serde",
+ "serde_json",
+]
+
 [[package]]
 name = "ahash"
 version = "0.7.8"
@@ -4180,6 +4195,8 @@ dependencies = [
  "async-trait",
  "collections",
  "dap",
+ "dotenvy",
+ "fs",
  "futures 0.3.31",
  "gpui",
  "json_dotpath",
@@ -4708,12 +4725,6 @@ dependencies = [
  "syn 2.0.101",
 ]
 
-[[package]]
-name = "dotenv"
-version = "0.15.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77c90badedccf4105eca100756a0b1289e191f6fcbdadd3cee1d2f614f97da8f"
-
 [[package]]
 name = "dotenvy"
 version = "0.15.7"
@@ -5147,7 +5158,7 @@ dependencies = [
  "collections",
  "debug_adapter_extension",
  "dirs 4.0.0",
- "dotenv",
+ "dotenvy",
  "env_logger 0.11.8",
  "extension",
  "fs",
@@ -14093,6 +14104,7 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fe8c9d1c68d67dd9f97ecbc6f932b60eb289c5dbddd8aa1405484a8fd2fcd984"
 dependencies = [
+ "chrono",
  "dyn-clone",
  "indexmap",
  "ref-cast",

Cargo.toml

@@ -2,9 +2,9 @@
 resolver = "2"
 members = [
     "crates/activity_indicator",
+    "crates/acp",
     "crates/agent_ui",
     "crates/agent",
-    "crates/agent2",
     "crates/agent_settings",
     "crates/anthropic",
     "crates/askpass",
@@ -216,8 +216,9 @@ edition = "2024"
 # Workspace member crates
 #
 
-activity_indicator = { path = "crates/activity_indicator" }
+acp = { path = "crates/acp" }
 agent = { path = "crates/agent" }
+activity_indicator = { path = "crates/activity_indicator" }
 agent_ui = { path = "crates/agent_ui" }
 agent_settings = { path = "crates/agent_settings" }
 ai = { path = "crates/ai" }
@@ -399,6 +400,7 @@ zlog_settings = { path = "crates/zlog_settings" }
 # External crates
 #
 
+agentic-coding-protocol = { path = "../agentic-coding-protocol" }
 aho-corasick = "1.1"
 alacritty_terminal = { git = "https://github.com/zed-industries/alacritty.git", branch = "add-hush-login-flag" }
 any_vec = "0.14"
@@ -450,7 +452,7 @@ dashmap = "6.0"
 derive_more = "0.99.17"
 dirs = "4.0"
 documented = "0.9.1"
-dotenv = "0.15.0"
+dotenvy = "0.15.0"
 ec4rs = "1.1"
 emojis = "0.6.1"
 env_logger = "0.11"
@@ -481,7 +483,7 @@ json_dotpath = "1.1"
 jsonschema = "0.30.0"
 jsonwebtoken = "9.3"
 jupyter-protocol = { git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734" }
-jupyter-websocket-client = {  git = "https://github.com/ConradIrwin/runtimed" ,rev = "7130c804216b6914355d15d0b91ea91f6babd734" }
+jupyter-websocket-client = { git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734" }
 libc = "0.2"
 libsqlite3-sys = { version = "0.30.1", features = ["bundled"] }
 linkify = "0.10.0"
@@ -492,7 +494,7 @@ metal = "0.29"
 moka = { version = "0.12.10", features = ["sync"] }
 naga = { version = "25.0", features = ["wgsl-in"] }
 nanoid = "0.4"
-nbformat = {  git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734" }
+nbformat = { git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734" }
 nix = "0.29"
 num-format = "0.4.4"
 objc = "0.2"
@@ -532,7 +534,7 @@ reqwest = { git = "https://github.com/zed-industries/reqwest.git", rev = "951c77
     "stream",
 ] }
 rsa = "0.9.6"
-runtimelib = {  git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734", default-features = false, features = [
+runtimelib = { git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734", default-features = false, features = [
     "async-dispatcher-runtime",
 ] }
 rust-embed = { version = "8.4", features = ["include-exclude"] }

crates/acp/Cargo.toml

@@ -0,0 +1,50 @@
+[package]
+name = "acp"
+version = "0.1.0"
+edition.workspace = true
+publish.workspace = true
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/acp.rs"
+doctest = false
+
+[features]
+test-support = ["gpui/test-support", "project/test-support"]
+
+[dependencies]
+agentic-coding-protocol = { path = "../../../agentic-coding-protocol" }
+anyhow.workspace = true
+async-trait.workspace = true
+base64.workspace = true
+buffer_diff.workspace = true
+chrono.workspace = true
+collections.workspace = true
+editor.workspace = true
+futures.workspace = true
+gpui.workspace = true
+language.workspace = true
+log.workspace = true
+markdown.workspace = true
+parking_lot.workspace = true
+project.workspace = true
+proto.workspace = true
+settings.workspace = true
+smol.workspace = true
+theme.workspace = true
+ui.workspace = true
+util.workspace = true
+uuid.workspace = true
+workspace-hack.workspace = true
+zed_actions.workspace = true
+
+[dev-dependencies]
+env_logger.workspace = true
+gpui = { workspace = true, "features" = ["test-support"] }
+project = { workspace = true, "features" = ["test-support"] }
+serde_json.workspace = true
+util.workspace = true
+settings.workspace = true

crates/acp/src/acp.rs

@@ -0,0 +1,748 @@
+mod server;
+mod thread_view;
+
+use agentic_coding_protocol::{self as acp, Role};
+use anyhow::{Context as _, Result};
+use buffer_diff::BufferDiff;
+use chrono::{DateTime, Utc};
+use editor::MultiBuffer;
+use futures::channel::oneshot;
+use gpui::{AppContext, Context, Entity, EventEmitter, SharedString, Task};
+use language::{Buffer, LanguageRegistry};
+use markdown::Markdown;
+use project::Project;
+use std::{mem, ops::Range, path::PathBuf, sync::Arc};
+use ui::{App, IconName};
+use util::{ResultExt, debug_panic};
+
+pub use server::AcpServer;
+pub use thread_view::AcpThreadView;
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ThreadId(SharedString);
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub struct FileVersion(u64);
+
+#[derive(Debug)]
+pub struct AgentThreadSummary {
+    pub id: ThreadId,
+    pub title: String,
+    pub created_at: DateTime<Utc>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct FileContent {
+    pub path: PathBuf,
+    pub version: FileVersion,
+    pub content: SharedString,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Message {
+    pub role: acp::Role,
+    pub chunks: Vec<MessageChunk>,
+}
+
+impl Message {
+    fn into_acp(self, cx: &App) -> acp::Message {
+        acp::Message {
+            role: self.role,
+            chunks: self
+                .chunks
+                .into_iter()
+                .map(|chunk| chunk.into_acp(cx))
+                .collect(),
+        }
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum MessageChunk {
+    Text {
+        chunk: Entity<Markdown>,
+    },
+    File {
+        content: FileContent,
+    },
+    Directory {
+        path: PathBuf,
+        contents: Vec<FileContent>,
+    },
+    Symbol {
+        path: PathBuf,
+        range: Range<u64>,
+        version: FileVersion,
+        name: SharedString,
+        content: SharedString,
+    },
+    Fetch {
+        url: SharedString,
+        content: SharedString,
+    },
+}
+
+impl MessageChunk {
+    pub fn from_acp(
+        chunk: acp::MessageChunk,
+        language_registry: Arc<LanguageRegistry>,
+        cx: &mut App,
+    ) -> Self {
+        match chunk {
+            acp::MessageChunk::Text { chunk } => MessageChunk::Text {
+                chunk: cx.new(|cx| Markdown::new(chunk.into(), Some(language_registry), None, cx)),
+            },
+        }
+    }
+
+    pub fn into_acp(self, cx: &App) -> acp::MessageChunk {
+        match self {
+            MessageChunk::Text { chunk } => acp::MessageChunk::Text {
+                chunk: chunk.read(cx).source().to_string(),
+            },
+            MessageChunk::File { .. } => todo!(),
+            MessageChunk::Directory { .. } => todo!(),
+            MessageChunk::Symbol { .. } => todo!(),
+            MessageChunk::Fetch { .. } => todo!(),
+        }
+    }
+
+    pub fn from_str(chunk: &str, language_registry: Arc<LanguageRegistry>, cx: &mut App) -> Self {
+        MessageChunk::Text {
+            chunk: cx.new(|cx| {
+                Markdown::new(chunk.to_owned().into(), Some(language_registry), None, cx)
+            }),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum AgentThreadEntryContent {
+    Message(Message),
+    ToolCall(ToolCall),
+}
+
+#[derive(Debug)]
+pub struct ToolCall {
+    id: ToolCallId,
+    label: Entity<Markdown>,
+    icon: IconName,
+    status: ToolCallStatus,
+}
+
+#[derive(Debug)]
+pub enum ToolCallStatus {
+    WaitingForConfirmation {
+        confirmation: acp::ToolCallConfirmation,
+        respond_tx: oneshot::Sender<acp::ToolCallConfirmationOutcome>,
+    },
+    Allowed {
+        status: acp::ToolCallStatus,
+        content: Option<ToolCallContent>,
+    },
+    Rejected,
+}
+
+#[derive(Debug)]
+pub enum ToolCallContent {
+    Markdown {
+        markdown: Entity<Markdown>,
+    },
+    Diff {
+        path: PathBuf,
+        diff: Entity<BufferDiff>,
+        buffer: Entity<MultiBuffer>,
+        _task: Task<Result<()>>,
+    },
+}
+
+/// A `ThreadEntryId` that is known to be a ToolCall
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct ToolCallId(ThreadEntryId);
+
+impl ToolCallId {
+    pub fn as_u64(&self) -> u64 {
+        self.0.0
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct ThreadEntryId(pub u64);
+
+impl ThreadEntryId {
+    pub fn post_inc(&mut self) -> Self {
+        let id = *self;
+        self.0 += 1;
+        id
+    }
+}
+
+#[derive(Debug)]
+pub struct ThreadEntry {
+    pub id: ThreadEntryId,
+    pub content: AgentThreadEntryContent,
+}
+
+pub struct AcpThread {
+    id: ThreadId,
+    next_entry_id: ThreadEntryId,
+    entries: Vec<ThreadEntry>,
+    server: Arc<AcpServer>,
+    title: SharedString,
+    project: Entity<Project>,
+}
+
+enum AcpThreadEvent {
+    NewEntry,
+    EntryUpdated(usize),
+}
+
+impl EventEmitter<AcpThreadEvent> for AcpThread {}
+
+impl AcpThread {
+    pub fn new(
+        server: Arc<AcpServer>,
+        thread_id: ThreadId,
+        entries: Vec<AgentThreadEntryContent>,
+        project: Entity<Project>,
+        _: &mut Context<Self>,
+    ) -> Self {
+        let mut next_entry_id = ThreadEntryId(0);
+        Self {
+            title: "A new agent2 thread".into(),
+            entries: entries
+                .into_iter()
+                .map(|entry| ThreadEntry {
+                    id: next_entry_id.post_inc(),
+                    content: entry,
+                })
+                .collect(),
+            server,
+            id: thread_id,
+            next_entry_id,
+            project,
+        }
+    }
+
+    pub fn title(&self) -> SharedString {
+        self.title.clone()
+    }
+
+    pub fn entries(&self) -> &[ThreadEntry] {
+        &self.entries
+    }
+
+    pub fn push_entry(
+        &mut self,
+        entry: AgentThreadEntryContent,
+        cx: &mut Context<Self>,
+    ) -> ThreadEntryId {
+        let id = self.next_entry_id.post_inc();
+        self.entries.push(ThreadEntry { id, content: entry });
+        cx.emit(AcpThreadEvent::NewEntry);
+        id
+    }
+
+    pub fn push_assistant_chunk(&mut self, chunk: acp::MessageChunk, cx: &mut Context<Self>) {
+        let entries_len = self.entries.len();
+        if let Some(last_entry) = self.entries.last_mut()
+            && let AgentThreadEntryContent::Message(Message {
+                ref mut chunks,
+                role: Role::Assistant,
+            }) = last_entry.content
+        {
+            cx.emit(AcpThreadEvent::EntryUpdated(entries_len - 1));
+
+            if let (
+                Some(MessageChunk::Text { chunk: old_chunk }),
+                acp::MessageChunk::Text { chunk: new_chunk },
+            ) = (chunks.last_mut(), &chunk)
+            {
+                old_chunk.update(cx, |old_chunk, cx| {
+                    old_chunk.append(&new_chunk, cx);
+                });
+            } else {
+                chunks.push(MessageChunk::from_acp(
+                    chunk,
+                    self.project.read(cx).languages().clone(),
+                    cx,
+                ));
+            }
+
+            return;
+        }
+
+        let chunk = MessageChunk::from_acp(chunk, self.project.read(cx).languages().clone(), cx);
+
+        self.push_entry(
+            AgentThreadEntryContent::Message(Message {
+                role: Role::Assistant,
+                chunks: vec![chunk],
+            }),
+            cx,
+        );
+    }
+
+    pub fn request_tool_call(
+        &mut self,
+        label: String,
+        icon: acp::Icon,
+        confirmation: acp::ToolCallConfirmation,
+        cx: &mut Context<Self>,
+    ) -> ToolCallRequest {
+        let (tx, rx) = oneshot::channel();
+
+        let status = ToolCallStatus::WaitingForConfirmation {
+            confirmation,
+            respond_tx: tx,
+        };
+
+        let id = self.insert_tool_call(label, status, icon, cx);
+        ToolCallRequest { id, outcome: rx }
+    }
+
+    pub fn push_tool_call(
+        &mut self,
+        label: String,
+        icon: acp::Icon,
+        cx: &mut Context<Self>,
+    ) -> ToolCallId {
+        let status = ToolCallStatus::Allowed {
+            status: acp::ToolCallStatus::Running,
+            content: None,
+        };
+
+        self.insert_tool_call(label, status, icon, cx)
+    }
+
+    fn insert_tool_call(
+        &mut self,
+        label: String,
+        status: ToolCallStatus,
+        icon: acp::Icon,
+        cx: &mut Context<Self>,
+    ) -> ToolCallId {
+        let language_registry = self.project.read(cx).languages().clone();
+
+        let entry_id = self.push_entry(
+            AgentThreadEntryContent::ToolCall(ToolCall {
+                // todo! clean up id creation
+                id: ToolCallId(ThreadEntryId(self.entries.len() as u64)),
+                label: cx.new(|cx| {
+                    Markdown::new(label.into(), Some(language_registry.clone()), None, cx)
+                }),
+                icon: acp_icon_to_ui_icon(icon),
+                status,
+            }),
+            cx,
+        );
+
+        ToolCallId(entry_id)
+    }
+
+    pub fn authorize_tool_call(
+        &mut self,
+        id: ToolCallId,
+        outcome: acp::ToolCallConfirmationOutcome,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(entry) = self.entry_mut(id.0) else {
+            return;
+        };
+
+        let AgentThreadEntryContent::ToolCall(call) = &mut entry.content else {
+            debug_panic!("expected ToolCall");
+            return;
+        };
+
+        let new_status = if outcome == acp::ToolCallConfirmationOutcome::Reject {
+            ToolCallStatus::Rejected
+        } else {
+            ToolCallStatus::Allowed {
+                status: acp::ToolCallStatus::Running,
+                content: None,
+            }
+        };
+
+        let curr_status = mem::replace(&mut call.status, new_status);
+
+        if let ToolCallStatus::WaitingForConfirmation { respond_tx, .. } = curr_status {
+            respond_tx.send(outcome).log_err();
+        } else {
+            debug_panic!("tried to authorize an already authorized tool call");
+        }
+
+        cx.emit(AcpThreadEvent::EntryUpdated(id.as_u64() as usize));
+    }
+
+    pub fn update_tool_call(
+        &mut self,
+        id: ToolCallId,
+        new_status: acp::ToolCallStatus,
+        new_content: Option<acp::ToolCallContent>,
+        cx: &mut Context<Self>,
+    ) -> Result<()> {
+        let language_registry = self.project.read(cx).languages().clone();
+        let entry = self.entry_mut(id.0).context("Entry not found")?;
+
+        match &mut entry.content {
+            AgentThreadEntryContent::ToolCall(call) => match &mut call.status {
+                ToolCallStatus::Allowed { content, status } => {
+                    *content = new_content.map(|new_content| match new_content {
+                        acp::ToolCallContent::Markdown { markdown } => ToolCallContent::Markdown {
+                            markdown: cx.new(|cx| {
+                                Markdown::new(
+                                    markdown.into(),
+                                    Some(language_registry.clone()),
+                                    None,
+                                    cx,
+                                )
+                            }),
+                        },
+                        acp::ToolCallContent::Diff {
+                            path,
+                            old_text,
+                            new_text,
+                        } => {
+                            let buffer = cx.new(|cx| Buffer::local(new_text, cx));
+                            let text_snapshot = buffer.read(cx).text_snapshot();
+                            let buffer_diff = cx.new(|cx| BufferDiff::new(&text_snapshot, cx));
+
+                            let multibuffer = cx.new(|cx| {
+                                let mut multibuffer = MultiBuffer::singleton(buffer.clone(), cx);
+                                multibuffer.add_diff(buffer_diff.clone(), cx);
+                                multibuffer
+                            });
+
+                            ToolCallContent::Diff {
+                                path: path.clone(),
+                                diff: buffer_diff.clone(),
+                                buffer: multibuffer,
+                                _task: cx.spawn(async move |_this, cx| {
+                                    let diff_snapshot = BufferDiff::update_diff(
+                                        buffer_diff.clone(),
+                                        text_snapshot.clone(),
+                                        old_text.map(|o| o.into()),
+                                        true,
+                                        true,
+                                        None,
+                                        Some(language_registry.clone()),
+                                        cx,
+                                    )
+                                    .await?;
+
+                                    buffer_diff.update(cx, |diff, cx| {
+                                        diff.set_snapshot(diff_snapshot, &text_snapshot, cx)
+                                    })?;
+
+                                    if let Some(language) = language_registry
+                                        .language_for_file_path(&path)
+                                        .await
+                                        .log_err()
+                                    {
+                                        buffer.update(cx, |buffer, cx| {
+                                            buffer.set_language(Some(language), cx)
+                                        })?;
+                                    }
+
+                                    anyhow::Ok(())
+                                }),
+                            }
+                        }
+                    });
+                    *status = new_status;
+                }
+                ToolCallStatus::WaitingForConfirmation { .. } => {
+                    anyhow::bail!("Tool call hasn't been authorized yet")
+                }
+                ToolCallStatus::Rejected => {
+                    anyhow::bail!("Tool call was rejected and therefore can't be updated")
+                }
+            },
+            _ => anyhow::bail!("Entry is not a tool call"),
+        }
+
+        cx.emit(AcpThreadEvent::EntryUpdated(id.as_u64() as usize));
+        Ok(())
+    }
+
+    fn entry_mut(&mut self, id: ThreadEntryId) -> Option<&mut ThreadEntry> {
+        let entry = self.entries.get_mut(id.0 as usize);
+        debug_assert!(
+            entry.is_some(),
+            "We shouldn't give out ids to entries that don't exist"
+        );
+        entry
+    }
+
+    /// Returns true if the last turn is awaiting tool authorization
+    pub fn waiting_for_tool_confirmation(&self) -> bool {
+        for entry in self.entries.iter().rev() {
+            match &entry.content {
+                AgentThreadEntryContent::ToolCall(call) => match call.status {
+                    ToolCallStatus::WaitingForConfirmation { .. } => return true,
+                    ToolCallStatus::Allowed { .. } | ToolCallStatus::Rejected => continue,
+                },
+                AgentThreadEntryContent::Message(_) => {
+                    // Reached the beginning of the turn
+                    return false;
+                }
+            }
+        }
+        false
+    }
+
+    pub fn send(&mut self, message: &str, cx: &mut Context<Self>) -> Task<Result<()>> {
+        let agent = self.server.clone();
+        let id = self.id.clone();
+        let chunk = MessageChunk::from_str(message, self.project.read(cx).languages().clone(), cx);
+        let message = Message {
+            role: Role::User,
+            chunks: vec![chunk],
+        };
+        self.push_entry(AgentThreadEntryContent::Message(message.clone()), cx);
+        let acp_message = message.into_acp(cx);
+        cx.spawn(async move |_, cx| {
+            agent.send_message(id, acp_message, cx).await?;
+            Ok(())
+        })
+    }
+}
+
+fn acp_icon_to_ui_icon(icon: acp::Icon) -> IconName {
+    match icon {
+        acp::Icon::FileSearch => IconName::FileSearch,
+        acp::Icon::Folder => IconName::Folder,
+        acp::Icon::Globe => IconName::Globe,
+        acp::Icon::Hammer => IconName::Hammer,
+        acp::Icon::LightBulb => IconName::LightBulb,
+        acp::Icon::Pencil => IconName::Pencil,
+        acp::Icon::Regex => IconName::Regex,
+        acp::Icon::Terminal => IconName::Terminal,
+    }
+}
+
+pub struct ToolCallRequest {
+    pub id: ToolCallId,
+    pub outcome: oneshot::Receiver<acp::ToolCallConfirmationOutcome>,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use futures::{FutureExt as _, channel::mpsc, select};
+    use gpui::{AsyncApp, TestAppContext};
+    use project::FakeFs;
+    use serde_json::json;
+    use settings::SettingsStore;
+    use smol::stream::StreamExt as _;
+    use std::{env, path::Path, process::Stdio, time::Duration};
+    use util::path;
+
+    fn init_test(cx: &mut TestAppContext) {
+        env_logger::try_init().ok();
+        cx.update(|cx| {
+            let settings_store = SettingsStore::test(cx);
+            cx.set_global(settings_store);
+            Project::init_settings(cx);
+            language::init(cx);
+        });
+    }
+
+    #[gpui::test]
+    async fn test_gemini_basic(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        cx.executor().allow_parking();
+
+        let fs = FakeFs::new(cx.executor());
+        let project = Project::test(fs, [], cx).await;
+        let server = gemini_acp_server(project.clone(), cx.to_async()).unwrap();
+        let thread = server.create_thread(&mut cx.to_async()).await.unwrap();
+        thread
+            .update(cx, |thread, cx| thread.send("Hello from Zed!", cx))
+            .await
+            .unwrap();
+
+        thread.read_with(cx, |thread, _| {
+            assert_eq!(thread.entries.len(), 2);
+            assert!(matches!(
+                thread.entries[0].content,
+                AgentThreadEntryContent::Message(Message {
+                    role: Role::User,
+                    ..
+                })
+            ));
+            assert!(matches!(
+                thread.entries[1].content,
+                AgentThreadEntryContent::Message(Message {
+                    role: Role::Assistant,
+                    ..
+                })
+            ));
+        });
+    }
+
+    #[gpui::test]
+    async fn test_gemini_tool_call(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        cx.executor().allow_parking();
+
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree(
+            path!("/private/tmp"),
+            json!({"foo": "Lorem ipsum dolor", "bar": "bar", "baz": "baz"}),
+        )
+        .await;
+        let project = Project::test(fs, [path!("/private/tmp").as_ref()], cx).await;
+        let server = gemini_acp_server(project.clone(), cx.to_async()).unwrap();
+        let thread = server.create_thread(&mut cx.to_async()).await.unwrap();
+        thread
+            .update(cx, |thread, cx| {
+                thread.send(
+                    "Read the '/private/tmp/foo' file and tell me what you see.",
+                    cx,
+                )
+            })
+            .await
+            .unwrap();
+        thread.read_with(cx, |thread, _cx| {
+            assert!(matches!(
+                &thread.entries()[1].content,
+                AgentThreadEntryContent::ToolCall(ToolCall {
+                    status: ToolCallStatus::Allowed { .. },
+                    ..
+                })
+            ));
+
+            assert!(matches!(
+                thread.entries[2].content,
+                AgentThreadEntryContent::Message(Message {
+                    role: Role::Assistant,
+                    ..
+                })
+            ));
+        });
+    }
+
+    #[gpui::test]
+    async fn test_gemini_tool_call_with_confirmation(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        cx.executor().allow_parking();
+
+        let fs = FakeFs::new(cx.executor());
+        let project = Project::test(fs, [path!("/private/tmp").as_ref()], cx).await;
+        let server = gemini_acp_server(project.clone(), cx.to_async()).unwrap();
+        let thread = server.create_thread(&mut cx.to_async()).await.unwrap();
+        let full_turn = thread.update(cx, |thread, cx| {
+            thread.send(r#"Run `echo "Hello, world!"`"#, cx)
+        });
+
+        run_until_tool_call(&thread, cx).await;
+
+        let tool_call_id = thread.read_with(cx, |thread, _cx| {
+            let AgentThreadEntryContent::ToolCall(ToolCall {
+                id,
+                status:
+                    ToolCallStatus::WaitingForConfirmation {
+                        confirmation: acp::ToolCallConfirmation::Execute { root_command, .. },
+                        ..
+                    },
+                ..
+            }) = &thread.entries()[1].content
+            else {
+                panic!();
+            };
+
+            assert_eq!(root_command, "echo");
+
+            *id
+        });
+
+        thread.update(cx, |thread, cx| {
+            thread.authorize_tool_call(tool_call_id, acp::ToolCallConfirmationOutcome::Allow, cx);
+
+            assert!(matches!(
+                &thread.entries()[1].content,
+                AgentThreadEntryContent::ToolCall(ToolCall {
+                    status: ToolCallStatus::Allowed { .. },
+                    ..
+                })
+            ));
+        });
+
+        full_turn.await.unwrap();
+
+        thread.read_with(cx, |thread, cx| {
+            let AgentThreadEntryContent::ToolCall(ToolCall {
+                status:
+                    ToolCallStatus::Allowed {
+                        content: Some(ToolCallContent::Markdown { markdown }),
+                        ..
+                    },
+                ..
+            }) = &thread.entries()[1].content
+            else {
+                panic!();
+            };
+
+            markdown.read_with(cx, |md, _cx| {
+                assert!(
+                    md.source().contains("Hello, world!"),
+                    r#"Expected '{}' to contain "Hello, world!""#,
+                    md.source()
+                );
+            });
+        });
+    }
+
+    async fn run_until_tool_call(thread: &Entity<AcpThread>, cx: &mut TestAppContext) {
+        let (mut tx, mut rx) = mpsc::channel::<()>(1);
+
+        let subscription = cx.update(|cx| {
+            cx.subscribe(thread, move |thread, _, cx| {
+                if thread
+                    .read(cx)
+                    .entries
+                    .iter()
+                    .any(|e| matches!(e.content, AgentThreadEntryContent::ToolCall(_)))
+                {
+                    tx.try_send(()).unwrap();
+                }
+            })
+        });
+
+        select! {
+            _ = futures::FutureExt::fuse(smol::Timer::after(Duration::from_secs(10))) => {
+                panic!("Timeout waiting for tool call")
+            }
+            _ = rx.next().fuse() => {
+                drop(subscription);
+            }
+        }
+    }
+
+    pub fn gemini_acp_server(project: Entity<Project>, mut cx: AsyncApp) -> Result<Arc<AcpServer>> {
+        let cli_path =
+            Path::new(env!("CARGO_MANIFEST_DIR")).join("../../../gemini-cli/packages/cli");
+        let mut command = util::command::new_smol_command("node");
+        command
+            .arg(cli_path)
+            .arg("--acp")
+            .current_dir("/private/tmp")
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::inherit())
+            .kill_on_drop(true);
+
+        if let Ok(gemini_key) = std::env::var("GEMINI_API_KEY") {
+            command.env("GEMINI_API_KEY", gemini_key);
+        }
+
+        let child = command.spawn().unwrap();
+
+        Ok(AcpServer::stdio(child, project, &mut cx))
+    }
+}

crates/acp/src/server.rs

@@ -0,0 +1,363 @@
+use crate::{AcpThread, ThreadEntryId, ThreadId, ToolCallId, ToolCallRequest};
+use agentic_coding_protocol as acp;
+use anyhow::{Context as _, Result};
+use async_trait::async_trait;
+use collections::HashMap;
+use gpui::{App, AppContext, AsyncApp, Context, Entity, Task, WeakEntity};
+use parking_lot::Mutex;
+use project::Project;
+use smol::process::Child;
+use std::{io::Write as _, path::Path, process::ExitStatus, sync::Arc};
+use util::ResultExt;
+
+pub struct AcpServer {
+    connection: Arc<acp::AgentConnection>,
+    threads: Arc<Mutex<HashMap<ThreadId, WeakEntity<AcpThread>>>>,
+    project: Entity<Project>,
+    exit_status: Arc<Mutex<Option<ExitStatus>>>,
+    _handler_task: Task<()>,
+    _io_task: Task<()>,
+}
+
+struct AcpClientDelegate {
+    project: Entity<Project>,
+    threads: Arc<Mutex<HashMap<ThreadId, WeakEntity<AcpThread>>>>,
+    cx: AsyncApp,
+    // sent_buffer_versions: HashMap<Entity<Buffer>, HashMap<u64, BufferSnapshot>>,
+}
+
+impl AcpClientDelegate {
+    fn new(
+        project: Entity<Project>,
+        threads: Arc<Mutex<HashMap<ThreadId, WeakEntity<AcpThread>>>>,
+        cx: AsyncApp,
+    ) -> Self {
+        Self {
+            project,
+            threads,
+            cx: cx,
+        }
+    }
+
+    fn update_thread<R>(
+        &self,
+        thread_id: &ThreadId,
+        cx: &mut App,
+        callback: impl FnOnce(&mut AcpThread, &mut Context<AcpThread>) -> R,
+    ) -> Option<R> {
+        let thread = self.threads.lock().get(&thread_id)?.clone();
+        let Some(thread) = thread.upgrade() else {
+            self.threads.lock().remove(&thread_id);
+            return None;
+        };
+        Some(thread.update(cx, callback))
+    }
+}
+
+#[async_trait(?Send)]
+impl acp::Client for AcpClientDelegate {
+    async fn stat(&self, params: acp::StatParams) -> Result<acp::StatResponse> {
+        let cx = &mut self.cx.clone();
+        self.project.update(cx, |project, cx| {
+            let path = project
+                .project_path_for_absolute_path(Path::new(&params.path), cx)
+                .context("Failed to get project path")?;
+
+            match project.entry_for_path(&path, cx) {
+                // todo! refresh entry?
+                None => Ok(acp::StatResponse {
+                    exists: false,
+                    is_directory: false,
+                }),
+                Some(entry) => Ok(acp::StatResponse {
+                    exists: entry.is_created(),
+                    is_directory: entry.is_dir(),
+                }),
+            }
+        })?
+    }
+
+    async fn stream_message_chunk(
+        &self,
+        params: acp::StreamMessageChunkParams,
+    ) -> Result<acp::StreamMessageChunkResponse> {
+        let cx = &mut self.cx.clone();
+
+        cx.update(|cx| {
+            self.update_thread(&params.thread_id.into(), cx, |thread, cx| {
+                thread.push_assistant_chunk(params.chunk, cx)
+            });
+        })?;
+
+        Ok(acp::StreamMessageChunkResponse)
+    }
+
+    async fn read_text_file(
+        &self,
+        request: acp::ReadTextFileParams,
+    ) -> Result<acp::ReadTextFileResponse> {
+        let cx = &mut self.cx.clone();
+        let buffer = self
+            .project
+            .update(cx, |project, cx| {
+                let path = project
+                    .project_path_for_absolute_path(Path::new(&request.path), cx)
+                    .context("Failed to get project path")?;
+                anyhow::Ok(project.open_buffer(path, cx))
+            })??
+            .await?;
+
+        buffer.update(cx, |buffer, _cx| {
+            let start = language::Point::new(request.line_offset.unwrap_or(0), 0);
+            let end = match request.line_limit {
+                None => buffer.max_point(),
+                Some(limit) => start + language::Point::new(limit + 1, 0),
+            };
+
+            let content: String = buffer.text_for_range(start..end).collect();
+
+            acp::ReadTextFileResponse {
+                content,
+                version: acp::FileVersion(0),
+            }
+        })
+    }
+
+    async fn read_binary_file(
+        &self,
+        request: acp::ReadBinaryFileParams,
+    ) -> Result<acp::ReadBinaryFileResponse> {
+        let cx = &mut self.cx.clone();
+        let file = self
+            .project
+            .update(cx, |project, cx| {
+                let (worktree, path) = project
+                    .find_worktree(Path::new(&request.path), cx)
+                    .context("Failed to get project path")?;
+
+                let task = worktree.update(cx, |worktree, cx| worktree.load_binary_file(&path, cx));
+                anyhow::Ok(task)
+            })??
+            .await?;
+
+        // todo! test
+        let content = cx
+            .background_spawn(async move {
+                let start = request.byte_offset.unwrap_or(0) as usize;
+                let end = request
+                    .byte_limit
+                    .map(|limit| (start + limit as usize).min(file.content.len()))
+                    .unwrap_or(file.content.len());
+
+                let range_content = &file.content[start..end];
+
+                let mut base64_content = Vec::new();
+                let mut base64_encoder = base64::write::EncoderWriter::new(
+                    std::io::Cursor::new(&mut base64_content),
+                    &base64::engine::general_purpose::STANDARD,
+                );
+                base64_encoder.write_all(range_content)?;
+                drop(base64_encoder);
+
+                // SAFETY: The base64 encoder should not produce non-UTF8.
+                unsafe { anyhow::Ok(String::from_utf8_unchecked(base64_content)) }
+            })
+            .await?;
+
+        Ok(acp::ReadBinaryFileResponse {
+            content,
+            // todo!
+            version: acp::FileVersion(0),
+        })
+    }
+
+    async fn glob_search(
+        &self,
+        _request: acp::GlobSearchParams,
+    ) -> Result<acp::GlobSearchResponse> {
+        todo!()
+    }
+
+    async fn request_tool_call_confirmation(
+        &self,
+        request: acp::RequestToolCallConfirmationParams,
+    ) -> Result<acp::RequestToolCallConfirmationResponse> {
+        let cx = &mut self.cx.clone();
+        let ToolCallRequest { id, outcome } = cx
+            .update(|cx| {
+                self.update_thread(&request.thread_id.into(), cx, |thread, cx| {
+                    thread.request_tool_call(request.label, request.icon, request.confirmation, cx)
+                })
+            })?
+            .context("Failed to update thread")?;
+
+        Ok(acp::RequestToolCallConfirmationResponse {
+            id: id.into(),
+            outcome: outcome.await?,
+        })
+    }
+
+    async fn push_tool_call(
+        &self,
+        request: acp::PushToolCallParams,
+    ) -> Result<acp::PushToolCallResponse> {
+        let cx = &mut self.cx.clone();
+        let entry_id = cx
+            .update(|cx| {
+                self.update_thread(&request.thread_id.into(), cx, |thread, cx| {
+                    thread.push_tool_call(request.label, request.icon, cx)
+                })
+            })?
+            .context("Failed to update thread")?;
+
+        Ok(acp::PushToolCallResponse {
+            id: entry_id.into(),
+        })
+    }
+
+    async fn update_tool_call(
+        &self,
+        request: acp::UpdateToolCallParams,
+    ) -> Result<acp::UpdateToolCallResponse> {
+        let cx = &mut self.cx.clone();
+
+        cx.update(|cx| {
+            self.update_thread(&request.thread_id.into(), cx, |thread, cx| {
+                thread.update_tool_call(
+                    request.tool_call_id.into(),
+                    request.status,
+                    request.content,
+                    cx,
+                )
+            })
+        })?
+        .context("Failed to update thread")??;
+
+        Ok(acp::UpdateToolCallResponse)
+    }
+}
+
+impl AcpServer {
+    pub fn stdio(mut process: Child, project: Entity<Project>, cx: &mut App) -> Arc<Self> {
+        let stdin = process.stdin.take().expect("process didn't have stdin");
+        let stdout = process.stdout.take().expect("process didn't have stdout");
+
+        let threads: Arc<Mutex<HashMap<ThreadId, WeakEntity<AcpThread>>>> = Default::default();
+        let (connection, handler_fut, io_fut) = acp::AgentConnection::connect_to_agent(
+            AcpClientDelegate::new(project.clone(), threads.clone(), cx.to_async()),
+            stdin,
+            stdout,
+        );
+
+        let exit_status: Arc<Mutex<Option<ExitStatus>>> = Default::default();
+        let io_task = cx.background_spawn({
+            let exit_status = exit_status.clone();
+            async move {
+                io_fut.await.log_err();
+                let result = process.status().await.log_err();
+                *exit_status.lock() = result;
+            }
+        });
+
+        Arc::new(Self {
+            project,
+            connection: Arc::new(connection),
+            threads,
+            exit_status,
+            _handler_task: cx.foreground_executor().spawn(handler_fut),
+            _io_task: io_task,
+        })
+    }
+
+    pub async fn initialize(&self) -> Result<acp::InitializeResponse> {
+        self.connection
+            .request(acp::InitializeParams)
+            .await
+            .map_err(to_anyhow)
+    }
+
+    pub async fn authenticate(&self) -> Result<()> {
+        self.connection
+            .request(acp::AuthenticateParams)
+            .await
+            .map_err(to_anyhow)?;
+
+        Ok(())
+    }
+
+    pub async fn create_thread(self: Arc<Self>, cx: &mut AsyncApp) -> Result<Entity<AcpThread>> {
+        let response = self
+            .connection
+            .request(acp::CreateThreadParams)
+            .await
+            .map_err(to_anyhow)?;
+
+        let thread_id: ThreadId = response.thread_id.into();
+        let server = self.clone();
+        let thread = cx.new(|_| AcpThread {
+            // todo!
+            title: "ACP Thread".into(),
+            id: thread_id.clone(), // Either<ErrorState, Id>
+            next_entry_id: ThreadEntryId(0),
+            entries: Vec::default(),
+            project: self.project.clone(),
+            server,
+        })?;
+        self.threads.lock().insert(thread_id, thread.downgrade());
+        Ok(thread)
+    }
+
+    pub async fn send_message(
+        &self,
+        thread_id: ThreadId,
+        message: acp::Message,
+        _cx: &mut AsyncApp,
+    ) -> Result<()> {
+        self.connection
+            .request(acp::SendMessageParams {
+                thread_id: thread_id.clone().into(),
+                message,
+            })
+            .await
+            .map_err(to_anyhow)?;
+        Ok(())
+    }
+
+    pub fn exit_status(&self) -> Option<ExitStatus> {
+        self.exit_status.lock().clone()
+    }
+}
+
+#[track_caller]
+fn to_anyhow(e: acp::Error) -> anyhow::Error {
+    log::error!(
+        "failed to send message: {code}: {message}",
+        code = e.code,
+        message = e.message
+    );
+    anyhow::anyhow!(e.message)
+}
+
+impl From<acp::ThreadId> for ThreadId {
+    fn from(thread_id: acp::ThreadId) -> Self {
+        Self(thread_id.0.into())
+    }
+}
+
+impl From<ThreadId> for acp::ThreadId {
+    fn from(thread_id: ThreadId) -> Self {
+        acp::ThreadId(thread_id.0.to_string())
+    }
+}
+
+impl From<acp::ToolCallId> for ToolCallId {
+    fn from(tool_call_id: acp::ToolCallId) -> Self {
+        Self(ThreadEntryId(tool_call_id.0))
+    }
+}
+
+impl From<ToolCallId> for acp::ToolCallId {
+    fn from(tool_call_id: ToolCallId) -> Self {
+        acp::ToolCallId(tool_call_id.as_u64())
+    }
+}

crates/agent/src/agent_profile.rs

@@ -111,7 +111,7 @@ mod tests {
     use assistant_tool::ToolRegistry;
     use collections::IndexMap;
     use gpui::SharedString;
-    use gpui::TestAppContext;
+    use gpui::{AppContext, TestAppContext};
     use http_client::FakeHttpClient;
     use project::Project;
     use settings::{Settings, SettingsStore};

crates/agent2/Cargo.toml

@@ -1,49 +0,0 @@
-[package]
-name = "agent2"
-version = "0.1.0"
-edition = "2021"
-license = "GPL-3.0-or-later"
-publish = false
-
-[lib]
-path = "src/agent2.rs"
-
-[lints]
-workspace = true
-
-[dependencies]
-anyhow.workspace = true
-assistant_tool.workspace = true
-assistant_tools.workspace = true
-chrono.workspace = true
-collections.workspace = true
-fs.workspace = true
-futures.workspace = true
-gpui.workspace = true
-handlebars = { workspace = true, features = ["rust-embed"] }
-language_model.workspace = true
-language_models.workspace = true
-parking_lot.workspace = true
-project.workspace = true
-rust-embed.workspace = true
-schemars.workspace = true
-serde.workspace = true
-serde_json.workspace = true
-settings.workspace = true
-smol.workspace = true
-thiserror.workspace = true
-util.workspace = true
-worktree.workspace = true
-
-[dev-dependencies]
-ctor.workspace = true
-client = { workspace = true, "features" = ["test-support"] }
-env_logger.workspace = true
-fs = { workspace = true, "features" = ["test-support"] }
-gpui = { workspace = true, "features" = ["test-support"] }
-gpui_tokio.workspace = true
-language_model = { workspace = true, "features" = ["test-support"] }
-project = { workspace = true, "features" = ["test-support"] }
-reqwest_client.workspace = true
-settings = { workspace = true, "features" = ["test-support"] }
-worktree = { workspace = true, "features" = ["test-support"] }

crates/agent2/src/agent2.rs

@@ -1,6 +0,0 @@
-mod prompts;
-mod templates;
-mod thread;
-mod tools;
-
-pub use thread::*;

crates/agent2/src/prompts.rs

@@ -1,29 +0,0 @@
-use crate::{
-    templates::{BaseTemplate, Template, Templates, WorktreeData},
-    thread::Prompt,
-};
-use anyhow::Result;
-use gpui::{App, Entity};
-use project::Project;
-
-struct BasePrompt {
-    project: Entity<Project>,
-}
-
-impl Prompt for BasePrompt {
-    fn render(&self, templates: &Templates, cx: &App) -> Result<String> {
-        BaseTemplate {
-            os: std::env::consts::OS.to_string(),
-            shell: util::get_system_shell(),
-            worktrees: self
-                .project
-                .read(cx)
-                .worktrees(cx)
-                .map(|worktree| WorktreeData {
-                    root_name: worktree.read(cx).root_name().to_string(),
-                })
-                .collect(),
-        }
-        .render(templates)
-    }
-}

crates/agent2/src/templates.rs

@@ -1,57 +0,0 @@
-use std::sync::Arc;
-
-use anyhow::Result;
-use handlebars::Handlebars;
-use rust_embed::RustEmbed;
-use serde::Serialize;
-
-#[derive(RustEmbed)]
-#[folder = "src/templates"]
-#[include = "*.hbs"]
-struct Assets;
-
-pub struct Templates(Handlebars<'static>);
-
-impl Templates {
-    pub fn new() -> Arc<Self> {
-        let mut handlebars = Handlebars::new();
-        handlebars.register_embed_templates::<Assets>().unwrap();
-        Arc::new(Self(handlebars))
-    }
-}
-
-pub trait Template: Sized {
-    const TEMPLATE_NAME: &'static str;
-
-    fn render(&self, templates: &Templates) -> Result<String>
-    where
-        Self: Serialize + Sized,
-    {
-        Ok(templates.0.render(Self::TEMPLATE_NAME, self)?)
-    }
-}
-
-#[derive(Serialize)]
-pub struct BaseTemplate {
-    pub os: String,
-    pub shell: String,
-    pub worktrees: Vec<WorktreeData>,
-}
-
-impl Template for BaseTemplate {
-    const TEMPLATE_NAME: &'static str = "base.hbs";
-}
-
-#[derive(Serialize)]
-pub struct WorktreeData {
-    pub root_name: String,
-}
-
-#[derive(Serialize)]
-pub struct GlobTemplate {
-    pub project_roots: String,
-}
-
-impl Template for GlobTemplate {
-    const TEMPLATE_NAME: &'static str = "glob.hbs";
-}

crates/agent2/src/templates/base.hbs

@@ -1,56 +0,0 @@
-You are a highly skilled software engineer with extensive knowledge in many programming languages, frameworks, design patterns, and best practices.
-
-## Communication
-
-1. Be conversational but professional.
-2. Refer to the USER in the second person and yourself in the first person.
-3. Format your responses in markdown. Use backticks to format file, directory, function, and class names.
-4. NEVER lie or make things up.
-5. Refrain from apologizing all the time when results are unexpected. Instead, just try your best to proceed or explain the circumstances to the user without apologizing.
-
-## Tool Use
-
-1. Make sure to adhere to the tools schema.
-2. Provide every required argument.
-3. DO NOT use tools to access items that are already available in the context section.
-4. Use only the tools that are currently available.
-5. DO NOT use a tool that is not available just because it appears in the conversation. This means the user turned it off.
-
-## Searching and Reading
-
-If you are unsure how to fulfill the user's request, gather more information with tool calls and/or clarifying questions.
-
-If appropriate, use tool calls to explore the current project, which contains the following root directories:
-
-{{#each worktrees}}
-- `{{root_name}}`
-{{/each}}
-
-- When providing paths to tools, the path should always begin with a path that starts with a project root directory listed above.
-- When looking for symbols in the project, prefer the `grep` tool.
-- As you learn about the structure of the project, use that information to scope `grep` searches to targeted subtrees of the project.
-- Bias towards not asking the user for help if you can find the answer yourself.
-
-## Fixing Diagnostics
-
-1. Make 1-2 attempts at fixing diagnostics, then defer to the user.
-2. Never simplify code you've written just to solve diagnostics. Complete, mostly correct code is more valuable than perfect code that doesn't solve the problem.
-
-## Debugging
-
-When debugging, only make code changes if you are certain that you can solve the problem.
-Otherwise, follow debugging best practices:
-1. Address the root cause instead of the symptoms.
-2. Add descriptive logging statements and error messages to track variable and code state.
-3. Add test functions and statements to isolate the problem.
-
-## Calling External APIs
-
-1. Unless explicitly requested by the user, use the best suited external APIs and packages to solve the task. There is no need to ask the user for permission.
-2. When selecting which version of an API or package to use, choose one that is compatible with the user's dependency management file. If no such file exists or if the package is not present, use the latest version that is in your training data.
-3. If an external API requires an API Key, be sure to point this out to the user. Adhere to best security practices (e.g. DO NOT hardcode an API key in a place where it can be exposed)
-
-## System Information
-
-Operating System: {{os}}
-Default Shell: {{shell}}

crates/agent2/src/templates/glob.hbs

@@ -1,8 +0,0 @@
-Find paths on disk with glob patterns.
-
-Assume that all glob patterns are matched in a project directory with the following entries.
-
-{{project_roots}}
-
-When searching with patterns that begin with literal path components, e.g. `foo/bar/**/*.rs`, be
-sure to anchor them with one of the directories listed above.

crates/agent2/src/thread.rs

@@ -1,420 +0,0 @@
-use crate::templates::Templates;
-use anyhow::{anyhow, Result};
-use futures::{channel::mpsc, future};
-use gpui::{App, Context, SharedString, Task};
-use language_model::{
-    CompletionIntent, CompletionMode, LanguageModel, LanguageModelCompletionError,
-    LanguageModelCompletionEvent, LanguageModelRequest, LanguageModelRequestMessage,
-    LanguageModelRequestTool, LanguageModelToolResult, LanguageModelToolResultContent,
-    LanguageModelToolSchemaFormat, LanguageModelToolUse, MessageContent, Role, StopReason,
-};
-use schemars::{JsonSchema, Schema};
-use serde::Deserialize;
-use smol::stream::StreamExt;
-use std::{collections::BTreeMap, sync::Arc};
-use util::ResultExt;
-
-#[derive(Debug)]
-pub struct AgentMessage {
-    pub role: Role,
-    pub content: Vec<MessageContent>,
-}
-
-pub type AgentResponseEvent = LanguageModelCompletionEvent;
-
-pub trait Prompt {
-    fn render(&self, prompts: &Templates, cx: &App) -> Result<String>;
-}
-
-pub struct Thread {
-    messages: Vec<AgentMessage>,
-    completion_mode: CompletionMode,
-    /// Holds the task that handles agent interaction until the end of the turn.
-    /// Survives across multiple requests as the model performs tool calls and
-    /// we run tools, report their results.
-    running_turn: Option<Task<()>>,
-    system_prompts: Vec<Arc<dyn Prompt>>,
-    tools: BTreeMap<SharedString, Arc<dyn AgentToolErased>>,
-    templates: Arc<Templates>,
-    // project: Entity<Project>,
-    // action_log: Entity<ActionLog>,
-}
-
-impl Thread {
-    pub fn new(templates: Arc<Templates>) -> Self {
-        Self {
-            messages: Vec::new(),
-            completion_mode: CompletionMode::Normal,
-            system_prompts: Vec::new(),
-            running_turn: None,
-            tools: BTreeMap::default(),
-            templates,
-        }
-    }
-
-    pub fn set_mode(&mut self, mode: CompletionMode) {
-        self.completion_mode = mode;
-    }
-
-    pub fn messages(&self) -> &[AgentMessage] {
-        &self.messages
-    }
-
-    pub fn add_tool(&mut self, tool: impl AgentTool) {
-        self.tools.insert(tool.name(), tool.erase());
-    }
-
-    pub fn remove_tool(&mut self, name: &str) -> bool {
-        self.tools.remove(name).is_some()
-    }
-
-    /// Sending a message results in the model streaming a response, which could include tool calls.
-    /// After calling tools, the model will stops and waits for any outstanding tool calls to be completed and their results sent.
-    /// The returned channel will report all the occurrences in which the model stops before erroring or ending its turn.
-    pub fn send(
-        &mut self,
-        model: Arc<dyn LanguageModel>,
-        content: impl Into<MessageContent>,
-        cx: &mut Context<Self>,
-    ) -> mpsc::UnboundedReceiver<Result<AgentResponseEvent, LanguageModelCompletionError>> {
-        cx.notify();
-        let (events_tx, events_rx) =
-            mpsc::unbounded::<Result<AgentResponseEvent, LanguageModelCompletionError>>();
-
-        let system_message = self.build_system_message(cx);
-        self.messages.extend(system_message);
-
-        self.messages.push(AgentMessage {
-            role: Role::User,
-            content: vec![content.into()],
-        });
-        self.running_turn = Some(cx.spawn(async move |thread, cx| {
-            let turn_result = async {
-                // Perform one request, then keep looping if the model makes tool calls.
-                let mut completion_intent = CompletionIntent::UserPrompt;
-                loop {
-                    let request = thread.update(cx, |thread, cx| {
-                        thread.build_completion_request(completion_intent, cx)
-                    })?;
-
-                    // println!(
-                    //     "request: {}",
-                    //     serde_json::to_string_pretty(&request).unwrap()
-                    // );
-
-                    // Stream events, appending to messages and collecting up tool uses.
-                    let mut events = model.stream_completion(request, cx).await?;
-                    let mut tool_uses = Vec::new();
-                    while let Some(event) = events.next().await {
-                        match event {
-                            Ok(event) => {
-                                thread
-                                    .update(cx, |thread, cx| {
-                                        tool_uses.extend(thread.handle_streamed_completion_event(
-                                            event,
-                                            events_tx.clone(),
-                                            cx,
-                                        ));
-                                    })
-                                    .ok();
-                            }
-                            Err(error) => {
-                                events_tx.unbounded_send(Err(error)).ok();
-                                break;
-                            }
-                        }
-                    }
-
-                    // If there are no tool uses, the turn is done.
-                    if tool_uses.is_empty() {
-                        break;
-                    }
-
-                    // If there are tool uses, wait for their results to be
-                    // computed, then send them together in a single message on
-                    // the next loop iteration.
-                    let tool_results = future::join_all(tool_uses).await;
-                    thread
-                        .update(cx, |thread, _cx| {
-                            thread.messages.push(AgentMessage {
-                                role: Role::User,
-                                content: tool_results.into_iter().map(Into::into).collect(),
-                            });
-                        })
-                        .ok();
-                    completion_intent = CompletionIntent::ToolResults;
-                }
-
-                Ok(())
-            }
-            .await;
-
-            if let Err(error) = turn_result {
-                events_tx.unbounded_send(Err(error)).ok();
-            }
-        }));
-        events_rx
-    }
-
-    pub fn build_system_message(&mut self, cx: &App) -> Option<AgentMessage> {
-        let mut system_message = AgentMessage {
-            role: Role::System,
-            content: Vec::new(),
-        };
-
-        for prompt in &self.system_prompts {
-            if let Some(rendered_prompt) = prompt.render(&self.templates, cx).log_err() {
-                system_message
-                    .content
-                    .push(MessageContent::Text(rendered_prompt));
-            }
-        }
-
-        (!system_message.content.is_empty()).then_some(system_message)
-    }
-
-    /// A helper method that's called on every streamed completion event.
-    /// Returns an optional tool result task, which the main agentic loop in
-    /// send will send back to the model when it resolves.
-    fn handle_streamed_completion_event(
-        &mut self,
-        event: LanguageModelCompletionEvent,
-        events_tx: mpsc::UnboundedSender<Result<AgentResponseEvent, LanguageModelCompletionError>>,
-        cx: &mut Context<Self>,
-    ) -> Option<Task<LanguageModelToolResult>> {
-        use LanguageModelCompletionEvent::*;
-        events_tx.unbounded_send(Ok(event.clone())).ok();
-
-        match event {
-            Text(new_text) => self.handle_text_event(new_text, cx),
-            Thinking { text, signature } => {
-                todo!()
-            }
-            ToolUse(tool_use) => {
-                return self.handle_tool_use_event(tool_use, cx);
-            }
-            StartMessage { role, .. } => {
-                self.messages.push(AgentMessage {
-                    role,
-                    content: Vec::new(),
-                });
-            }
-            UsageUpdate(_) => {}
-            Stop(stop_reason) => self.handle_stop_event(stop_reason),
-            StatusUpdate(_completion_request_status) => {}
-            RedactedThinking { data } => todo!(),
-            ToolUseJsonParseError {
-                id,
-                tool_name,
-                raw_input,
-                json_parse_error,
-            } => todo!(),
-        }
-
-        None
-    }
-
-    fn handle_stop_event(&mut self, stop_reason: StopReason) {
-        match stop_reason {
-            StopReason::EndTurn | StopReason::ToolUse => {}
-            StopReason::MaxTokens => todo!(),
-            StopReason::Refusal => todo!(),
-        }
-    }
-
-    fn handle_text_event(&mut self, new_text: String, cx: &mut Context<Self>) {
-        let last_message = self.last_assistant_message();
-        if let Some(MessageContent::Text(text)) = last_message.content.last_mut() {
-            text.push_str(&new_text);
-        } else {
-            last_message.content.push(MessageContent::Text(new_text));
-        }
-
-        cx.notify();
-    }
-
-    fn handle_tool_use_event(
-        &mut self,
-        tool_use: LanguageModelToolUse,
-        cx: &mut Context<Self>,
-    ) -> Option<Task<LanguageModelToolResult>> {
-        cx.notify();
-
-        let last_message = self.last_assistant_message();
-
-        // Ensure the last message ends in the current tool use
-        let push_new_tool_use = last_message.content.last_mut().map_or(true, |content| {
-            if let MessageContent::ToolUse(last_tool_use) = content {
-                if last_tool_use.id == tool_use.id {
-                    *last_tool_use = tool_use.clone();
-                    false
-                } else {
-                    true
-                }
-            } else {
-                true
-            }
-        });
-        if push_new_tool_use {
-            last_message.content.push(tool_use.clone().into());
-        }
-
-        if !tool_use.is_input_complete {
-            return None;
-        }
-
-        if let Some(tool) = self.tools.get(tool_use.name.as_ref()) {
-            let pending_tool_result = tool.clone().run(tool_use.input, cx);
-
-            Some(cx.foreground_executor().spawn(async move {
-                match pending_tool_result.await {
-                    Ok(tool_output) => LanguageModelToolResult {
-                        tool_use_id: tool_use.id,
-                        tool_name: tool_use.name,
-                        is_error: false,
-                        content: LanguageModelToolResultContent::Text(Arc::from(tool_output)),
-                        output: None,
-                    },
-                    Err(error) => LanguageModelToolResult {
-                        tool_use_id: tool_use.id,
-                        tool_name: tool_use.name,
-                        is_error: true,
-                        content: LanguageModelToolResultContent::Text(Arc::from(error.to_string())),
-                        output: None,
-                    },
-                }
-            }))
-        } else {
-            Some(Task::ready(LanguageModelToolResult {
-                content: LanguageModelToolResultContent::Text(Arc::from(format!(
-                    "No tool named {} exists",
-                    tool_use.name
-                ))),
-                tool_use_id: tool_use.id,
-                tool_name: tool_use.name,
-                is_error: true,
-                output: None,
-            }))
-        }
-    }
-
-    /// Guarantees the last message is from the assistant and returns a mutable reference.
-    fn last_assistant_message(&mut self) -> &mut AgentMessage {
-        if self
-            .messages
-            .last()
-            .map_or(true, |m| m.role != Role::Assistant)
-        {
-            self.messages.push(AgentMessage {
-                role: Role::Assistant,
-                content: Vec::new(),
-            });
-        }
-        self.messages.last_mut().unwrap()
-    }
-
-    fn build_completion_request(
-        &self,
-        completion_intent: CompletionIntent,
-        cx: &mut App,
-    ) -> LanguageModelRequest {
-        LanguageModelRequest {
-            thread_id: None,
-            prompt_id: None,
-            intent: Some(completion_intent),
-            mode: Some(self.completion_mode),
-            messages: self.build_request_messages(),
-            tools: self
-                .tools
-                .values()
-                .filter_map(|tool| {
-                    Some(LanguageModelRequestTool {
-                        name: tool.name().to_string(),
-                        description: tool.description(cx).to_string(),
-                        input_schema: tool
-                            .input_schema(LanguageModelToolSchemaFormat::JsonSchema)
-                            .log_err()?,
-                    })
-                })
-                .collect(),
-            tool_choice: None,
-            stop: Vec::new(),
-            temperature: None,
-        }
-    }
-
-    fn build_request_messages(&self) -> Vec<LanguageModelRequestMessage> {
-        self.messages
-            .iter()
-            .map(|message| LanguageModelRequestMessage {
-                role: message.role,
-                content: message.content.clone(),
-                cache: false,
-            })
-            .collect()
-    }
-}
-
-pub trait AgentTool
-where
-    Self: 'static + Sized,
-{
-    type Input: for<'de> Deserialize<'de> + JsonSchema;
-
-    fn name(&self) -> SharedString;
-    fn description(&self, _cx: &mut App) -> SharedString {
-        let schema = schemars::schema_for!(Self::Input);
-        SharedString::new(
-            schema
-                .get("description")
-                .and_then(|description| description.as_str())
-                .unwrap_or_default(),
-        )
-    }
-
-    /// Returns the JSON schema that describes the tool's input.
-    fn input_schema(&self, format: LanguageModelToolSchemaFormat) -> Schema {
-        assistant_tools::root_schema_for::<Self::Input>(format)
-    }
-
-    /// Runs the tool with the provided input.
-    fn run(self: Arc<Self>, input: Self::Input, cx: &mut App) -> Task<Result<String>>;
-
-    fn erase(self) -> Arc<dyn AgentToolErased> {
-        Arc::new(Erased(Arc::new(self)))
-    }
-}
-
-pub struct Erased<T>(T);
-
-pub trait AgentToolErased {
-    fn name(&self) -> SharedString;
-    fn description(&self, cx: &mut App) -> SharedString;
-    fn input_schema(&self, format: LanguageModelToolSchemaFormat) -> Result<serde_json::Value>;
-    fn run(self: Arc<Self>, input: serde_json::Value, cx: &mut App) -> Task<Result<String>>;
-}
-
-impl<T> AgentToolErased for Erased<Arc<T>>
-where
-    T: AgentTool,
-{
-    fn name(&self) -> SharedString {
-        self.0.name()
-    }
-
-    fn description(&self, cx: &mut App) -> SharedString {
-        self.0.description(cx)
-    }
-
-    fn input_schema(&self, format: LanguageModelToolSchemaFormat) -> Result<serde_json::Value> {
-        Ok(serde_json::to_value(self.0.input_schema(format))?)
-    }
-
-    fn run(self: Arc<Self>, input: serde_json::Value, cx: &mut App) -> Task<Result<String>> {
-        let parsed_input: Result<T::Input> = serde_json::from_value(input).map_err(Into::into);
-        match parsed_input {
-            Ok(input) => self.0.clone().run(input, cx),
-            Err(error) => Task::ready(Err(anyhow!(error))),
-        }
-    }
-}

crates/agent2/src/thread/tests.rs

@@ -1,254 +0,0 @@
-use super::*;
-use client::{proto::language_server_prompt_request, Client, UserStore};
-use fs::FakeFs;
-use gpui::{AppContext, Entity, TestAppContext};
-use language_model::{
-    LanguageModel, LanguageModelCompletionError, LanguageModelCompletionEvent,
-    LanguageModelRegistry, MessageContent, StopReason,
-};
-use reqwest_client::ReqwestClient;
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
-use smol::stream::StreamExt;
-use std::{sync::Arc, time::Duration};
-
-mod test_tools;
-use test_tools::*;
-
-#[gpui::test]
-async fn test_echo(cx: &mut TestAppContext) {
-    let AgentTest { model, agent, .. } = setup(cx).await;
-
-    let events = agent
-        .update(cx, |agent, cx| {
-            agent.send(model.clone(), "Testing: Reply with 'Hello'", cx)
-        })
-        .collect()
-        .await;
-    agent.update(cx, |agent, _cx| {
-        assert_eq!(
-            agent.messages.last().unwrap().content,
-            vec![MessageContent::Text("Hello".to_string())]
-        );
-    });
-    assert_eq!(stop_events(events), vec![StopReason::EndTurn]);
-}
-
-#[gpui::test]
-async fn test_basic_tool_calls(cx: &mut TestAppContext) {
-    let AgentTest { model, agent, .. } = setup(cx).await;
-
-    // Test a tool call that's likely to complete *before* streaming stops.
-    let events = agent
-        .update(cx, |agent, cx| {
-            agent.add_tool(EchoTool);
-            agent.send(
-                model.clone(),
-                "Now test the echo tool with 'Hello'. Does it work? Say 'Yes' or 'No'.",
-                cx,
-            )
-        })
-        .collect()
-        .await;
-    assert_eq!(
-        stop_events(events),
-        vec![StopReason::ToolUse, StopReason::EndTurn]
-    );
-
-    // Test a tool calls that's likely to complete *after* streaming stops.
-    let events = agent
-        .update(cx, |agent, cx| {
-            agent.remove_tool(&AgentTool::name(&EchoTool));
-            agent.add_tool(DelayTool);
-            agent.send(
-                model.clone(),
-                "Now call the delay tool with 200ms. When the timer goes off, then you echo the output of the tool.",
-                cx,
-            )
-        })
-        .collect()
-        .await;
-    assert_eq!(
-        stop_events(events),
-        vec![StopReason::ToolUse, StopReason::EndTurn]
-    );
-    agent.update(cx, |agent, _cx| {
-        assert!(agent
-            .messages
-            .last()
-            .unwrap()
-            .content
-            .iter()
-            .any(|content| {
-                if let MessageContent::Text(text) = content {
-                    text.contains("Ding")
-                } else {
-                    false
-                }
-            }));
-    });
-}
-
-#[gpui::test]
-async fn test_streaming_tool_calls(cx: &mut TestAppContext) {
-    let AgentTest { model, agent, .. } = setup(cx).await;
-
-    // Test a tool call that's likely to complete *before* streaming stops.
-    let mut events = agent.update(cx, |agent, cx| {
-        agent.add_tool(WordListTool);
-        agent.send(model.clone(), "Test the word_list tool.", cx)
-    });
-
-    let mut saw_partial_tool_use = false;
-    while let Some(event) = events.next().await {
-        if let Ok(LanguageModelCompletionEvent::ToolUse(tool_use_event)) = event {
-            agent.update(cx, |agent, _cx| {
-                // Look for a tool use in the agent's last message
-                let last_content = agent.messages().last().unwrap().content.last().unwrap();
-                if let MessageContent::ToolUse(last_tool_use) = last_content {
-                    assert_eq!(last_tool_use.name.as_ref(), "word_list");
-                    if tool_use_event.is_input_complete {
-                        last_tool_use
-                            .input
-                            .get("a")
-                            .expect("'a' has streamed because input is now complete");
-                        last_tool_use
-                            .input
-                            .get("g")
-                            .expect("'g' has streamed because input is now complete");
-                    } else {
-                        if !last_tool_use.is_input_complete
-                            && last_tool_use.input.get("g").is_none()
-                        {
-                            saw_partial_tool_use = true;
-                        }
-                    }
-                } else {
-                    panic!("last content should be a tool use");
-                }
-            });
-        }
-    }
-
-    assert!(
-        saw_partial_tool_use,
-        "should see at least one partially streamed tool use in the history"
-    );
-}
-
-#[gpui::test]
-async fn test_concurrent_tool_calls(cx: &mut TestAppContext) {
-    let AgentTest { model, agent, .. } = setup(cx).await;
-
-    // Test concurrent tool calls with different delay times
-    let events = agent
-        .update(cx, |agent, cx| {
-            agent.add_tool(DelayTool);
-            agent.send(
-                model.clone(),
-                "Call the delay tool twice in the same message. Once with 100ms. Once with 300ms. When both timers are complete, describe the outputs.",
-                cx,
-            )
-        })
-        .collect()
-        .await;
-
-    let stop_reasons = stop_events(events);
-    if stop_reasons.len() == 2 {
-        assert_eq!(stop_reasons, vec![StopReason::ToolUse, StopReason::EndTurn]);
-    } else if stop_reasons.len() == 3 {
-        assert_eq!(
-            stop_reasons,
-            vec![
-                StopReason::ToolUse,
-                StopReason::ToolUse,
-                StopReason::EndTurn
-            ]
-        );
-    } else {
-        panic!("Expected either 1 or 2 tool uses followed by end turn");
-    }
-
-    agent.update(cx, |agent, _cx| {
-        let last_message = agent.messages.last().unwrap();
-        let text = last_message
-            .content
-            .iter()
-            .filter_map(|content| {
-                if let MessageContent::Text(text) = content {
-                    Some(text.as_str())
-                } else {
-                    None
-                }
-            })
-            .collect::<String>();
-
-        assert!(text.contains("Ding"));
-    });
-}
-
-/// Filters out the stop events for asserting against in tests
-fn stop_events(
-    result_events: Vec<Result<AgentResponseEvent, LanguageModelCompletionError>>,
-) -> Vec<StopReason> {
-    result_events
-        .into_iter()
-        .filter_map(|event| match event.unwrap() {
-            LanguageModelCompletionEvent::Stop(stop_reason) => Some(stop_reason),
-            _ => None,
-        })
-        .collect()
-}
-
-struct AgentTest {
-    model: Arc<dyn LanguageModel>,
-    agent: Entity<Thread>,
-}
-
-async fn setup(cx: &mut TestAppContext) -> AgentTest {
-    cx.executor().allow_parking();
-    cx.update(settings::init);
-    let fs = FakeFs::new(cx.executor().clone());
-    // let project = Project::test(fs.clone(), [], cx).await;
-    // let action_log = cx.new(|_| ActionLog::new(project.clone()));
-    let templates = Templates::new();
-    let agent = cx.new(|_| Thread::new(templates));
-
-    let model = cx
-        .update(|cx| {
-            gpui_tokio::init(cx);
-            let http_client = ReqwestClient::user_agent("agent tests").unwrap();
-            cx.set_http_client(Arc::new(http_client));
-
-            client::init_settings(cx);
-            let client = Client::production(cx);
-            let user_store = cx.new(|cx| UserStore::new(client.clone(), cx));
-            language_model::init(client.clone(), cx);
-            language_models::init(user_store.clone(), client.clone(), cx);
-
-            let models = LanguageModelRegistry::read_global(cx);
-            let model = models
-                .available_models(cx)
-                .find(|model| model.id().0 == "claude-3-7-sonnet-latest")
-                .unwrap();
-
-            let provider = models.provider(&model.provider_id()).unwrap();
-            let authenticated = provider.authenticate(cx);
-
-            cx.spawn(async move |cx| {
-                authenticated.await.unwrap();
-                model
-            })
-        })
-        .await;
-
-    AgentTest { model, agent }
-}
-
-#[cfg(test)]
-#[ctor::ctor]
-fn init_logger() {
-    if std::env::var("RUST_LOG").is_ok() {
-        env_logger::init();
-    }
-}

crates/agent2/src/thread/tests/test_tools.rs

@@ -1,83 +0,0 @@
-use super::*;
-
-/// A tool that echoes its input
-#[derive(JsonSchema, Serialize, Deserialize)]
-pub struct EchoToolInput {
-    /// The text to echo.
-    text: String,
-}
-
-pub struct EchoTool;
-
-impl AgentTool for EchoTool {
-    type Input = EchoToolInput;
-
-    fn name(&self) -> SharedString {
-        "echo".into()
-    }
-
-    fn run(self: Arc<Self>, input: Self::Input, _cx: &mut App) -> Task<Result<String>> {
-        Task::ready(Ok(input.text))
-    }
-}
-
-/// A tool that waits for a specified delay
-#[derive(JsonSchema, Serialize, Deserialize)]
-pub struct DelayToolInput {
-    /// The delay in milliseconds.
-    ms: u64,
-}
-
-pub struct DelayTool;
-
-impl AgentTool for DelayTool {
-    type Input = DelayToolInput;
-
-    fn name(&self) -> SharedString {
-        "delay".into()
-    }
-
-    fn run(self: Arc<Self>, input: Self::Input, cx: &mut App) -> Task<Result<String>>
-    where
-        Self: Sized,
-    {
-        cx.foreground_executor().spawn(async move {
-            smol::Timer::after(Duration::from_millis(input.ms)).await;
-            Ok("Ding".to_string())
-        })
-    }
-}
-
-/// A tool that takes an object with map from letters to random words starting with that letter.
-/// All fiealds are required! Pass a word for every letter!
-#[derive(JsonSchema, Serialize, Deserialize)]
-pub struct WordListInput {
-    /// Provide a random word that starts with A.
-    a: Option<String>,
-    /// Provide a random word that starts with B.
-    b: Option<String>,
-    /// Provide a random word that starts with C.
-    c: Option<String>,
-    /// Provide a random word that starts with D.
-    d: Option<String>,
-    /// Provide a random word that starts with E.
-    e: Option<String>,
-    /// Provide a random word that starts with F.
-    f: Option<String>,
-    /// Provide a random word that starts with G.
-    g: Option<String>,
-}
-
-pub struct WordListTool;
-
-impl AgentTool for WordListTool {
-    type Input = WordListInput;
-
-    fn name(&self) -> SharedString {
-        "word_list".into()
-    }
-
-    fn run(self: Arc<Self>, _input: Self::Input, _cx: &mut App) -> Task<Result<String>> {
-        Task::ready(Ok("ok".to_string()))
-    }
-}

crates/agent2/src/tools.rs

@@ -1 +0,0 @@
-mod glob;

crates/agent2/src/tools/glob.rs

@@ -1,76 +0,0 @@
-use anyhow::{anyhow, Result};
-use gpui::{App, AppContext, Entity, SharedString, Task};
-use project::Project;
-use schemars::JsonSchema;
-use serde::Deserialize;
-use std::{path::PathBuf, sync::Arc};
-use util::paths::PathMatcher;
-use worktree::Snapshot as WorktreeSnapshot;
-
-use crate::{
-    templates::{GlobTemplate, Template, Templates},
-    thread::AgentTool,
-};
-
-// Description is dynamic, see `fn description` below
-#[derive(Deserialize, JsonSchema)]
-struct GlobInput {
-    /// A POSIX glob pattern
-    glob: SharedString,
-}
-
-struct GlobTool {
-    project: Entity<Project>,
-    templates: Arc<Templates>,
-}
-
-impl AgentTool for GlobTool {
-    type Input = GlobInput;
-
-    fn name(&self) -> SharedString {
-        "glob".into()
-    }
-
-    fn description(&self, cx: &mut App) -> SharedString {
-        let project_roots = self
-            .project
-            .read(cx)
-            .worktrees(cx)
-            .map(|worktree| worktree.read(cx).root_name().into())
-            .collect::<Vec<String>>()
-            .join("\n");
-
-        GlobTemplate { project_roots }
-            .render(&self.templates)
-            .expect("template failed to render")
-            .into()
-    }
-
-    fn run(self: Arc<Self>, input: Self::Input, cx: &mut App) -> Task<Result<String>> {
-        let path_matcher = match PathMatcher::new([&input.glob]) {
-            Ok(matcher) => matcher,
-            Err(error) => return Task::ready(Err(anyhow!(error))),
-        };
-
-        let snapshots: Vec<WorktreeSnapshot> = self
-            .project
-            .read(cx)
-            .worktrees(cx)
-            .map(|worktree| worktree.read(cx).snapshot())
-            .collect();
-
-        cx.background_spawn(async move {
-            let paths = snapshots.iter().flat_map(|snapshot| {
-                let root_name = PathBuf::from(snapshot.root_name());
-                snapshot
-                    .entries(false, 0)
-                    .map(move |entry| root_name.join(&entry.path))
-                    .filter(|path| path_matcher.is_match(&path))
-            });
-            let output = paths
-                .map(|path| format!("{}\n", path.display()))
-                .collect::<String>();
-            Ok(output)
-        })
-    }
-}

crates/agent_ui/Cargo.toml

@@ -13,12 +13,10 @@ path = "src/agent_ui.rs"
 doctest = false
 
 [features]
-test-support = [
-    "gpui/test-support",
-    "language/test-support",
-]
+test-support = ["gpui/test-support", "language/test-support"]
 
 [dependencies]
+acp.workspace = true
 agent.workspace = true
 agent_settings.workspace = true
 anyhow.workspace = true

crates/agent_ui/src/agent_panel.rs

@@ -7,6 +7,7 @@ use std::time::Duration;
 use db::kvp::{Dismissable, KEY_VALUE_STORE};
 use serde::{Deserialize, Serialize};
 
+use crate::NewGeminiThread;
 use crate::language_model_selector::ToggleModelSelector;
 use crate::{
     AddContextServer, AgentDiffPane, ContinueThread, ContinueWithBurnMode,
@@ -109,6 +110,12 @@ pub fn init(cx: &mut App) {
                         panel.update(cx, |panel, cx| panel.new_prompt_editor(window, cx));
                     }
                 })
+                .register_action(|workspace, _: &NewGeminiThread, window, cx| {
+                    if let Some(panel) = workspace.panel::<AgentPanel>(cx) {
+                        workspace.focus_panel::<AgentPanel>(window, cx);
+                        panel.update(cx, |panel, cx| panel.new_gemini_thread(window, cx));
+                    }
+                })
                 .register_action(|workspace, action: &OpenRulesLibrary, window, cx| {
                     if let Some(panel) = workspace.panel::<AgentPanel>(cx) {
                         workspace.focus_panel::<AgentPanel>(window, cx);
@@ -125,6 +132,7 @@ pub fn init(cx: &mut App) {
                                 let thread = thread.read(cx).thread().clone();
                                 AgentDiffPane::deploy_in_workspace(thread, workspace, window, cx);
                             }
+                            ActiveView::AcpThread { .. } => todo!(),
                             ActiveView::TextThread { .. }
                             | ActiveView::History
                             | ActiveView::Configuration => {}
@@ -188,6 +196,9 @@ enum ActiveView {
         message_editor: Entity<MessageEditor>,
         _subscriptions: Vec<gpui::Subscription>,
     },
+    AcpThread {
+        thread_view: Entity<acp::AcpThreadView>,
+    },
     TextThread {
         context_editor: Entity<TextThreadEditor>,
         title_editor: Entity<Editor>,
@@ -207,7 +218,9 @@ enum WhichFontSize {
 impl ActiveView {
     pub fn which_font_size_used(&self) -> WhichFontSize {
         match self {
-            ActiveView::Thread { .. } | ActiveView::History => WhichFontSize::AgentFont,
+            ActiveView::Thread { .. } | ActiveView::AcpThread { .. } | ActiveView::History => {
+                WhichFontSize::AgentFont
+            }
             ActiveView::TextThread { .. } => WhichFontSize::BufferFont,
             ActiveView::Configuration => WhichFontSize::None,
         }
@@ -238,6 +251,9 @@ impl ActiveView {
                             thread.scroll_to_bottom(cx);
                         });
                     }
+                    ActiveView::AcpThread { .. } => {
+                        // todo!
+                    }
                     ActiveView::TextThread { .. }
                     | ActiveView::History
                     | ActiveView::Configuration => {}
@@ -653,6 +669,9 @@ impl AgentPanel {
                             .clone()
                             .update(cx, |thread, cx| thread.get_or_init_configured_model(cx));
                     }
+                    ActiveView::AcpThread { .. } => {
+                        // todo!
+                    }
                     ActiveView::TextThread { .. }
                     | ActiveView::History
                     | ActiveView::Configuration => {}
@@ -733,6 +752,9 @@ impl AgentPanel {
             ActiveView::Thread { thread, .. } => {
                 thread.update(cx, |thread, cx| thread.cancel_last_completion(window, cx));
             }
+            ActiveView::AcpThread { thread_view, .. } => {
+                thread_view.update(cx, |thread_element, _cx| thread_element.cancel());
+            }
             ActiveView::TextThread { .. } | ActiveView::History | ActiveView::Configuration => {}
         }
     }
@@ -740,6 +762,10 @@ impl AgentPanel {
     fn active_message_editor(&self) -> Option<&Entity<MessageEditor>> {
         match &self.active_view {
             ActiveView::Thread { message_editor, .. } => Some(message_editor),
+            ActiveView::AcpThread { .. } => {
+                // todo!
+                None
+            }
             ActiveView::TextThread { .. } | ActiveView::History | ActiveView::Configuration => None,
         }
     }
@@ -862,6 +888,19 @@ impl AgentPanel {
         context_editor.focus_handle(cx).focus(window);
     }
 
+    fn new_gemini_thread(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let project = self.project.clone();
+
+        cx.spawn_in(window, async move |this, cx| {
+            let thread_view =
+                cx.new_window_entity(|window, cx| acp::AcpThreadView::new(project, window, cx))?;
+            this.update_in(cx, |this, window, cx| {
+                this.set_active_view(ActiveView::AcpThread { thread_view }, window, cx);
+            })
+        })
+        .detach();
+    }
+
     fn deploy_rules_library(
         &mut self,
         action: &OpenRulesLibrary,
@@ -994,6 +1033,7 @@ impl AgentPanel {
                 cx,
             )
         });
+
         let message_editor = cx.new(|cx| {
             MessageEditor::new(
                 self.fs.clone(),
@@ -1018,6 +1058,7 @@ impl AgentPanel {
     pub fn go_back(&mut self, _: &workspace::GoBack, window: &mut Window, cx: &mut Context<Self>) {
         match self.active_view {
             ActiveView::Configuration | ActiveView::History => {
+                // todo! check go back works correctly
                 if let Some(previous_view) = self.previous_view.take() {
                     self.active_view = previous_view;
 
@@ -1025,6 +1066,9 @@ impl AgentPanel {
                         ActiveView::Thread { message_editor, .. } => {
                             message_editor.focus_handle(cx).focus(window);
                         }
+                        ActiveView::AcpThread { .. } => {
+                            todo!()
+                        }
                         ActiveView::TextThread { context_editor, .. } => {
                             context_editor.focus_handle(cx).focus(window);
                         }
@@ -1144,6 +1188,7 @@ impl AgentPanel {
                     })
                     .log_err();
             }
+            ActiveView::AcpThread { .. } => todo!(),
             ActiveView::TextThread { .. } | ActiveView::History | ActiveView::Configuration => {}
         }
     }
@@ -1197,6 +1242,9 @@ impl AgentPanel {
                 )
                 .detach_and_log_err(cx);
             }
+            ActiveView::AcpThread { .. } => {
+                todo!()
+            }
             ActiveView::TextThread { .. } | ActiveView::History | ActiveView::Configuration => {}
         }
     }
@@ -1231,6 +1279,10 @@ impl AgentPanel {
     pub(crate) fn active_thread(&self, cx: &App) -> Option<Entity<Thread>> {
         match &self.active_view {
             ActiveView::Thread { thread, .. } => Some(thread.read(cx).thread().clone()),
+            ActiveView::AcpThread { .. } => {
+                // todo!
+                None
+            }
             _ => None,
         }
     }
@@ -1336,6 +1388,9 @@ impl AgentPanel {
                     });
                 }
             }
+            ActiveView::AcpThread { .. } => {
+                // todo!
+            }
             _ => {}
         }
 
@@ -1351,6 +1406,9 @@ impl AgentPanel {
                     }
                 })
             }
+            ActiveView::AcpThread { .. } => {
+                // todo! push history entry
+            }
             _ => {}
         }
 
@@ -1437,6 +1495,7 @@ impl Focusable for AgentPanel {
     fn focus_handle(&self, cx: &App) -> FocusHandle {
         match &self.active_view {
             ActiveView::Thread { message_editor, .. } => message_editor.focus_handle(cx),
+            ActiveView::AcpThread { thread_view, .. } => thread_view.focus_handle(cx),
             ActiveView::History => self.history.focus_handle(cx),
             ActiveView::TextThread { context_editor, .. } => context_editor.focus_handle(cx),
             ActiveView::Configuration => {
@@ -1593,6 +1652,9 @@ impl AgentPanel {
                         .into_any_element(),
                 }
             }
+            ActiveView::AcpThread { thread_view } => Label::new(thread_view.read(cx).title(cx))
+                .truncate()
+                .into_any_element(),
             ActiveView::TextThread {
                 title_editor,
                 context_editor,
@@ -1727,6 +1789,10 @@ impl AgentPanel {
 
         let active_thread = match &self.active_view {
             ActiveView::Thread { thread, .. } => Some(thread.read(cx).thread().clone()),
+            ActiveView::AcpThread { .. } => {
+                // todo!
+                None
+            }
             ActiveView::TextThread { .. } | ActiveView::History | ActiveView::Configuration => None,
         };
 
@@ -1755,6 +1821,7 @@ impl AgentPanel {
                     menu = menu
                         .action("New Thread", NewThread::default().boxed_clone())
                         .action("New Text Thread", NewTextThread.boxed_clone())
+                        .action("New Gemini Thread", NewGeminiThread.boxed_clone())
                         .when_some(active_thread, |this, active_thread| {
                             let thread = active_thread.read(cx);
                             if !thread.is_empty() {
@@ -1893,6 +1960,10 @@ impl AgentPanel {
                 message_editor,
                 ..
             } => (thread.read(cx), message_editor.read(cx)),
+            ActiveView::AcpThread { .. } => {
+                // todo!
+                return None;
+            }
             ActiveView::TextThread { .. } | ActiveView::History | ActiveView::Configuration => {
                 return None;
             }
@@ -2031,6 +2102,10 @@ impl AgentPanel {
                     return false;
                 }
             }
+            ActiveView::AcpThread { .. } => {
+                // todo!
+                return false;
+            }
             ActiveView::TextThread { .. } | ActiveView::History | ActiveView::Configuration => {
                 return false;
             }
@@ -2615,6 +2690,10 @@ impl AgentPanel {
     ) -> Option<AnyElement> {
         let active_thread = match &self.active_view {
             ActiveView::Thread { thread, .. } => thread,
+            ActiveView::AcpThread { .. } => {
+                // todo!
+                return None;
+            }
             ActiveView::TextThread { .. } | ActiveView::History | ActiveView::Configuration => {
                 return None;
             }
@@ -2961,6 +3040,9 @@ impl AgentPanel {
                     .detach();
                 });
             }
+            ActiveView::AcpThread { .. } => {
+                unimplemented!()
+            }
             ActiveView::TextThread { context_editor, .. } => {
                 context_editor.update(cx, |context_editor, cx| {
                     TextThreadEditor::insert_dragged_files(
@@ -3034,6 +3116,9 @@ impl Render for AgentPanel {
                         });
                         this.continue_conversation(window, cx);
                     }
+                    ActiveView::AcpThread { .. } => {
+                        todo!()
+                    }
                     ActiveView::TextThread { .. }
                     | ActiveView::History
                     | ActiveView::Configuration => {}
@@ -3075,6 +3160,12 @@ impl Render for AgentPanel {
                     })
                     .child(h_flex().child(message_editor.clone()))
                     .child(self.render_drag_target(cx)),
+                ActiveView::AcpThread { thread_view, .. } => parent
+                    .relative()
+                    .child(thread_view.clone())
+                    // todo!
+                    // .child(h_flex().child(self.message_editor.clone()))
+                    .child(self.render_drag_target(cx)),
                 ActiveView::History => parent.child(self.history.clone()),
                 ActiveView::TextThread {
                     context_editor,

crates/agent_ui/src/agent_ui.rs

@@ -55,6 +55,7 @@ actions!(
     agent,
     [
         NewTextThread,
+        NewGeminiThread,
         ToggleContextPicker,
         ToggleNavigationMenu,
         ToggleOptionsMenu,
@@ -65,7 +66,6 @@ actions!(
         OpenHistory,
         AddContextServer,
         RemoveSelectedThread,
-        Chat,
         ChatWithFollow,
         CycleNextInlineAssist,
         CyclePreviousInlineAssist,

crates/agent_ui/src/message_editor.rs

@@ -47,13 +47,14 @@ use ui::{
 };
 use util::ResultExt as _;
 use workspace::{CollaboratorId, Workspace};
+use zed_actions::agent::Chat;
 use zed_llm_client::CompletionIntent;
 
 use crate::context_picker::{ContextPicker, ContextPickerCompletionProvider, crease_for_mention};
 use crate::context_strip::{ContextStrip, ContextStripEvent, SuggestContextKind};
 use crate::profile_selector::ProfileSelector;
 use crate::{
-    ActiveThread, AgentDiffPane, Chat, ChatWithFollow, ExpandMessageEditor, Follow, KeepAll,
+    ActiveThread, AgentDiffPane, ChatWithFollow, ExpandMessageEditor, Follow, KeepAll,
     ModelUsageContext, NewThread, OpenAgentDiff, RejectAll, RemoveAllContext, ToggleBurnMode,
     ToggleContextPicker, ToggleProfileSelector, register_agent_preview,
 };

crates/assistant_tools/src/assistant_tools.rs

@@ -46,7 +46,6 @@ pub use find_path_tool::FindPathToolInput;
 pub use grep_tool::{GrepTool, GrepToolInput};
 pub use open_tool::OpenTool;
 pub use read_file_tool::{ReadFileTool, ReadFileToolInput};
-pub use schema::root_schema_for;
 pub use terminal_tool::TerminalTool;
 
 pub fn init(http_client: Arc<HttpClientWithUrl>, cx: &mut App) {

crates/assistant_tools/src/fixtures/delete_run_git_blame/after.rs

@@ -1,328 +0,0 @@
-use crate::commit::get_messages;
-use crate::{GitRemote, Oid};
-use anyhow::{Context as _, Result, anyhow};
-use collections::{HashMap, HashSet};
-use futures::AsyncWriteExt;
-use gpui::SharedString;
-use serde::{Deserialize, Serialize};
-use std::process::Stdio;
-use std::{ops::Range, path::Path};
-use text::Rope;
-use time::OffsetDateTime;
-use time::UtcOffset;
-use time::macros::format_description;
-
-pub use git2 as libgit;
-
-#[derive(Debug, Clone, Default)]
-pub struct Blame {
-    pub entries: Vec<BlameEntry>,
-    pub messages: HashMap<Oid, String>,
-    pub remote_url: Option<String>,
-}
-
-#[derive(Clone, Debug, Default)]
-pub struct ParsedCommitMessage {
-    pub message: SharedString,
-    pub permalink: Option<url::Url>,
-    pub pull_request: Option<crate::hosting_provider::PullRequest>,
-    pub remote: Option<GitRemote>,
-}
-
-impl Blame {
-    pub async fn for_path(
-        git_binary: &Path,
-        working_directory: &Path,
-        path: &Path,
-        content: &Rope,
-        remote_url: Option<String>,
-    ) -> Result<Self> {
-        let output = run_git_blame(git_binary, working_directory, path, content).await?;
-        let mut entries = parse_git_blame(&output)?;
-        entries.sort_unstable_by(|a, b| a.range.start.cmp(&b.range.start));
-
-        let mut unique_shas = HashSet::default();
-
-        for entry in entries.iter_mut() {
-            unique_shas.insert(entry.sha);
-        }
-
-        let shas = unique_shas.into_iter().collect::<Vec<_>>();
-        let messages = get_messages(working_directory, &shas)
-            .await
-            .context("failed to get commit messages")?;
-
-        Ok(Self {
-            entries,
-            messages,
-            remote_url,
-        })
-    }
-}
-
-const GIT_BLAME_NO_COMMIT_ERROR: &str = "fatal: no such ref: HEAD";
-const GIT_BLAME_NO_PATH: &str = "fatal: no such path";
-
-#[derive(Serialize, Deserialize, Default, Debug, Clone, PartialEq, Eq)]
-pub struct BlameEntry {
-    pub sha: Oid,
-
-    pub range: Range<u32>,
-
-    pub original_line_number: u32,
-
-    pub author: Option<String>,
-    pub author_mail: Option<String>,
-    pub author_time: Option<i64>,
-    pub author_tz: Option<String>,
-
-    pub committer_name: Option<String>,
-    pub committer_email: Option<String>,
-    pub committer_time: Option<i64>,
-    pub committer_tz: Option<String>,
-
-    pub summary: Option<String>,
-
-    pub previous: Option<String>,
-    pub filename: String,
-}
-
-impl BlameEntry {
-    // Returns a BlameEntry by parsing the first line of a `git blame --incremental`
-    // entry. The line MUST have this format:
-    //
-    //     <40-byte-hex-sha1> <sourceline> <resultline> <num-lines>
-    fn new_from_blame_line(line: &str) -> Result<BlameEntry> {
-        let mut parts = line.split_whitespace();
-
-        let sha = parts
-            .next()
-            .and_then(|line| line.parse::<Oid>().ok())
-            .ok_or_else(|| anyhow!("failed to parse sha"))?;
-
-        let original_line_number = parts
-            .next()
-            .and_then(|line| line.parse::<u32>().ok())
-            .ok_or_else(|| anyhow!("Failed to parse original line number"))?;
-        let final_line_number = parts
-            .next()
-            .and_then(|line| line.parse::<u32>().ok())
-            .ok_or_else(|| anyhow!("Failed to parse final line number"))?;
-
-        let line_count = parts
-            .next()
-            .and_then(|line| line.parse::<u32>().ok())
-            .ok_or_else(|| anyhow!("Failed to parse final line number"))?;
-
-        let start_line = final_line_number.saturating_sub(1);
-        let end_line = start_line + line_count;
-        let range = start_line..end_line;
-
-        Ok(Self {
-            sha,
-            range,
-            original_line_number,
-            ..Default::default()
-        })
-    }
-
-    pub fn author_offset_date_time(&self) -> Result<time::OffsetDateTime> {
-        if let (Some(author_time), Some(author_tz)) = (self.author_time, &self.author_tz) {
-            let format = format_description!("[offset_hour][offset_minute]");
-            let offset = UtcOffset::parse(author_tz, &format)?;
-            let date_time_utc = OffsetDateTime::from_unix_timestamp(author_time)?;
-
-            Ok(date_time_utc.to_offset(offset))
-        } else {
-            // Directly return current time in UTC if there's no committer time or timezone
-            Ok(time::OffsetDateTime::now_utc())
-        }
-    }
-}
-
-// parse_git_blame parses the output of `git blame --incremental`, which returns
-// all the blame-entries for a given path incrementally, as it finds them.
-//
-// Each entry *always* starts with:
-//
-//     <40-byte-hex-sha1> <sourceline> <resultline> <num-lines>
-//
-// Each entry *always* ends with:
-//
-//     filename <whitespace-quoted-filename-goes-here>
-//
-// Line numbers are 1-indexed.
-//
-// A `git blame --incremental` entry looks like this:
-//
-//    6ad46b5257ba16d12c5ca9f0d4900320959df7f4 2 2 1
-//    author Joe Schmoe
-//    author-mail <joe.schmoe@example.com>
-//    author-time 1709741400
-//    author-tz +0100
-//    committer Joe Schmoe
-//    committer-mail <joe.schmoe@example.com>
-//    committer-time 1709741400
-//    committer-tz +0100
-//    summary Joe's cool commit
-//    previous 486c2409237a2c627230589e567024a96751d475 index.js
-//    filename index.js
-//
-// If the entry has the same SHA as an entry that was already printed then no
-// signature information is printed:
-//
-//    6ad46b5257ba16d12c5ca9f0d4900320959df7f4 3 4 1
-//    previous 486c2409237a2c627230589e567024a96751d475 index.js
-//    filename index.js
-//
-// More about `--incremental` output: https://mirrors.edge.kernel.org/pub/software/scm/git/docs/git-blame.html
-fn parse_git_blame(output: &str) -> Result<Vec<BlameEntry>> {
-    let mut entries: Vec<BlameEntry> = Vec::new();
-    let mut index: HashMap<Oid, usize> = HashMap::default();
-
-    let mut current_entry: Option<BlameEntry> = None;
-
-    for line in output.lines() {
-        let mut done = false;
-
-        match &mut current_entry {
-            None => {
-                let mut new_entry = BlameEntry::new_from_blame_line(line)?;
-
-                if let Some(existing_entry) = index
-                    .get(&new_entry.sha)
-                    .and_then(|slot| entries.get(*slot))
-                {
-                    new_entry.author.clone_from(&existing_entry.author);
-                    new_entry
-                        .author_mail
-                        .clone_from(&existing_entry.author_mail);
-                    new_entry.author_time = existing_entry.author_time;
-                    new_entry.author_tz.clone_from(&existing_entry.author_tz);
-                    new_entry
-                        .committer_name
-                        .clone_from(&existing_entry.committer_name);
-                    new_entry
-                        .committer_email
-                        .clone_from(&existing_entry.committer_email);
-                    new_entry.committer_time = existing_entry.committer_time;
-                    new_entry
-                        .committer_tz
-                        .clone_from(&existing_entry.committer_tz);
-                    new_entry.summary.clone_from(&existing_entry.summary);
-                }
-
-                current_entry.replace(new_entry);
-            }
-            Some(entry) => {
-                let Some((key, value)) = line.split_once(' ') else {
-                    continue;
-                };
-                let is_committed = !entry.sha.is_zero();
-                match key {
-                    "filename" => {
-                        entry.filename = value.into();
-                        done = true;
-                    }
-                    "previous" => entry.previous = Some(value.into()),
-
-                    "summary" if is_committed => entry.summary = Some(value.into()),
-                    "author" if is_committed => entry.author = Some(value.into()),
-                    "author-mail" if is_committed => entry.author_mail = Some(value.into()),
-                    "author-time" if is_committed => {
-                        entry.author_time = Some(value.parse::<i64>()?)
-                    }
-                    "author-tz" if is_committed => entry.author_tz = Some(value.into()),
-
-                    "committer" if is_committed => entry.committer_name = Some(value.into()),
-                    "committer-mail" if is_committed => entry.committer_email = Some(value.into()),
-                    "committer-time" if is_committed => {
-                        entry.committer_time = Some(value.parse::<i64>()?)
-                    }
-                    "committer-tz" if is_committed => entry.committer_tz = Some(value.into()),
-                    _ => {}
-                }
-            }
-        };
-
-        if done {
-            if let Some(entry) = current_entry.take() {
-                index.insert(entry.sha, entries.len());
-
-                // We only want annotations that have a commit.
-                if !entry.sha.is_zero() {
-                    entries.push(entry);
-                }
-            }
-        }
-    }
-
-    Ok(entries)
-}
-
-#[cfg(test)]
-mod tests {
-    use std::path::PathBuf;
-
-    use super::BlameEntry;
-    use super::parse_git_blame;
-
-    fn read_test_data(filename: &str) -> String {
-        let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-        path.push("test_data");
-        path.push(filename);
-
-        std::fs::read_to_string(&path)
-            .unwrap_or_else(|_| panic!("Could not read test data at {:?}. Is it generated?", path))
-    }
-
-    fn assert_eq_golden(entries: &Vec<BlameEntry>, golden_filename: &str) {
-        let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-        path.push("test_data");
-        path.push("golden");
-        path.push(format!("{}.json", golden_filename));
-
-        let mut have_json =
-            serde_json::to_string_pretty(&entries).expect("could not serialize entries to JSON");
-        // We always want to save with a trailing newline.
-        have_json.push('\n');
-
-        let update = std::env::var("UPDATE_GOLDEN")
-            .map(|val| val.eq_ignore_ascii_case("true"))
-            .unwrap_or(false);
-
-        if update {
-            std::fs::create_dir_all(path.parent().unwrap())
-                .expect("could not create golden test data directory");
-            std::fs::write(&path, have_json).expect("could not write out golden data");
-        } else {
-            let want_json =
-                std::fs::read_to_string(&path).unwrap_or_else(|_| {
-                    panic!("could not read golden test data file at {:?}. Did you run the test with UPDATE_GOLDEN=true before?", path);
-                }).replace("\r\n", "\n");
-
-            pretty_assertions::assert_eq!(have_json, want_json, "wrong blame entries");
-        }
-    }
-
-    #[test]
-    fn test_parse_git_blame_not_committed() {
-        let output = read_test_data("blame_incremental_not_committed");
-        let entries = parse_git_blame(&output).unwrap();
-        assert_eq_golden(&entries, "blame_incremental_not_committed");
-    }
-
-    #[test]
-    fn test_parse_git_blame_simple() {
-        let output = read_test_data("blame_incremental_simple");
-        let entries = parse_git_blame(&output).unwrap();
-        assert_eq_golden(&entries, "blame_incremental_simple");
-    }
-
-    #[test]
-    fn test_parse_git_blame_complex() {
-        let output = read_test_data("blame_incremental_complex");
-        let entries = parse_git_blame(&output).unwrap();
-        assert_eq_golden(&entries, "blame_incremental_complex");
-    }
-}

crates/assistant_tools/src/fixtures/delete_run_git_blame/before.rs

@@ -1,374 +0,0 @@
-use crate::commit::get_messages;
-use crate::{GitRemote, Oid};
-use anyhow::{Context as _, Result, anyhow};
-use collections::{HashMap, HashSet};
-use futures::AsyncWriteExt;
-use gpui::SharedString;
-use serde::{Deserialize, Serialize};
-use std::process::Stdio;
-use std::{ops::Range, path::Path};
-use text::Rope;
-use time::OffsetDateTime;
-use time::UtcOffset;
-use time::macros::format_description;
-
-pub use git2 as libgit;
-
-#[derive(Debug, Clone, Default)]
-pub struct Blame {
-    pub entries: Vec<BlameEntry>,
-    pub messages: HashMap<Oid, String>,
-    pub remote_url: Option<String>,
-}
-
-#[derive(Clone, Debug, Default)]
-pub struct ParsedCommitMessage {
-    pub message: SharedString,
-    pub permalink: Option<url::Url>,
-    pub pull_request: Option<crate::hosting_provider::PullRequest>,
-    pub remote: Option<GitRemote>,
-}
-
-impl Blame {
-    pub async fn for_path(
-        git_binary: &Path,
-        working_directory: &Path,
-        path: &Path,
-        content: &Rope,
-        remote_url: Option<String>,
-    ) -> Result<Self> {
-        let output = run_git_blame(git_binary, working_directory, path, content).await?;
-        let mut entries = parse_git_blame(&output)?;
-        entries.sort_unstable_by(|a, b| a.range.start.cmp(&b.range.start));
-
-        let mut unique_shas = HashSet::default();
-
-        for entry in entries.iter_mut() {
-            unique_shas.insert(entry.sha);
-        }
-
-        let shas = unique_shas.into_iter().collect::<Vec<_>>();
-        let messages = get_messages(working_directory, &shas)
-            .await
-            .context("failed to get commit messages")?;
-
-        Ok(Self {
-            entries,
-            messages,
-            remote_url,
-        })
-    }
-}
-
-const GIT_BLAME_NO_COMMIT_ERROR: &str = "fatal: no such ref: HEAD";
-const GIT_BLAME_NO_PATH: &str = "fatal: no such path";
-
-async fn run_git_blame(
-    git_binary: &Path,
-    working_directory: &Path,
-    path: &Path,
-    contents: &Rope,
-) -> Result<String> {
-    let mut child = util::command::new_smol_command(git_binary)
-        .current_dir(working_directory)
-        .arg("blame")
-        .arg("--incremental")
-        .arg("--contents")
-        .arg("-")
-        .arg(path.as_os_str())
-        .stdin(Stdio::piped())
-        .stdout(Stdio::piped())
-        .stderr(Stdio::piped())
-        .spawn()
-        .map_err(|e| anyhow!("Failed to start git blame process: {}", e))?;
-
-    let stdin = child
-        .stdin
-        .as_mut()
-        .context("failed to get pipe to stdin of git blame command")?;
-
-    for chunk in contents.chunks() {
-        stdin.write_all(chunk.as_bytes()).await?;
-    }
-    stdin.flush().await?;
-
-    let output = child
-        .output()
-        .await
-        .map_err(|e| anyhow!("Failed to read git blame output: {}", e))?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        let trimmed = stderr.trim();
-        if trimmed == GIT_BLAME_NO_COMMIT_ERROR || trimmed.contains(GIT_BLAME_NO_PATH) {
-            return Ok(String::new());
-        }
-        return Err(anyhow!("git blame process failed: {}", stderr));
-    }
-
-    Ok(String::from_utf8(output.stdout)?)
-}
-
-#[derive(Serialize, Deserialize, Default, Debug, Clone, PartialEq, Eq)]
-pub struct BlameEntry {
-    pub sha: Oid,
-
-    pub range: Range<u32>,
-
-    pub original_line_number: u32,
-
-    pub author: Option<String>,
-    pub author_mail: Option<String>,
-    pub author_time: Option<i64>,
-    pub author_tz: Option<String>,
-
-    pub committer_name: Option<String>,
-    pub committer_email: Option<String>,
-    pub committer_time: Option<i64>,
-    pub committer_tz: Option<String>,
-
-    pub summary: Option<String>,
-
-    pub previous: Option<String>,
-    pub filename: String,
-}
-
-impl BlameEntry {
-    // Returns a BlameEntry by parsing the first line of a `git blame --incremental`
-    // entry. The line MUST have this format:
-    //
-    //     <40-byte-hex-sha1> <sourceline> <resultline> <num-lines>
-    fn new_from_blame_line(line: &str) -> Result<BlameEntry> {
-        let mut parts = line.split_whitespace();
-
-        let sha = parts
-            .next()
-            .and_then(|line| line.parse::<Oid>().ok())
-            .ok_or_else(|| anyhow!("failed to parse sha"))?;
-
-        let original_line_number = parts
-            .next()
-            .and_then(|line| line.parse::<u32>().ok())
-            .ok_or_else(|| anyhow!("Failed to parse original line number"))?;
-        let final_line_number = parts
-            .next()
-            .and_then(|line| line.parse::<u32>().ok())
-            .ok_or_else(|| anyhow!("Failed to parse final line number"))?;
-
-        let line_count = parts
-            .next()
-            .and_then(|line| line.parse::<u32>().ok())
-            .ok_or_else(|| anyhow!("Failed to parse final line number"))?;
-
-        let start_line = final_line_number.saturating_sub(1);
-        let end_line = start_line + line_count;
-        let range = start_line..end_line;
-
-        Ok(Self {
-            sha,
-            range,
-            original_line_number,
-            ..Default::default()
-        })
-    }
-
-    pub fn author_offset_date_time(&self) -> Result<time::OffsetDateTime> {
-        if let (Some(author_time), Some(author_tz)) = (self.author_time, &self.author_tz) {
-            let format = format_description!("[offset_hour][offset_minute]");
-            let offset = UtcOffset::parse(author_tz, &format)?;
-            let date_time_utc = OffsetDateTime::from_unix_timestamp(author_time)?;
-
-            Ok(date_time_utc.to_offset(offset))
-        } else {
-            // Directly return current time in UTC if there's no committer time or timezone
-            Ok(time::OffsetDateTime::now_utc())
-        }
-    }
-}
-
-// parse_git_blame parses the output of `git blame --incremental`, which returns
-// all the blame-entries for a given path incrementally, as it finds them.
-//
-// Each entry *always* starts with:
-//
-//     <40-byte-hex-sha1> <sourceline> <resultline> <num-lines>
-//
-// Each entry *always* ends with:
-//
-//     filename <whitespace-quoted-filename-goes-here>
-//
-// Line numbers are 1-indexed.
-//
-// A `git blame --incremental` entry looks like this:
-//
-//    6ad46b5257ba16d12c5ca9f0d4900320959df7f4 2 2 1
-//    author Joe Schmoe
-//    author-mail <joe.schmoe@example.com>
-//    author-time 1709741400
-//    author-tz +0100
-//    committer Joe Schmoe
-//    committer-mail <joe.schmoe@example.com>
-//    committer-time 1709741400
-//    committer-tz +0100
-//    summary Joe's cool commit
-//    previous 486c2409237a2c627230589e567024a96751d475 index.js
-//    filename index.js
-//
-// If the entry has the same SHA as an entry that was already printed then no
-// signature information is printed:
-//
-//    6ad46b5257ba16d12c5ca9f0d4900320959df7f4 3 4 1
-//    previous 486c2409237a2c627230589e567024a96751d475 index.js
-//    filename index.js
-//
-// More about `--incremental` output: https://mirrors.edge.kernel.org/pub/software/scm/git/docs/git-blame.html
-fn parse_git_blame(output: &str) -> Result<Vec<BlameEntry>> {
-    let mut entries: Vec<BlameEntry> = Vec::new();
-    let mut index: HashMap<Oid, usize> = HashMap::default();
-
-    let mut current_entry: Option<BlameEntry> = None;
-
-    for line in output.lines() {
-        let mut done = false;
-
-        match &mut current_entry {
-            None => {
-                let mut new_entry = BlameEntry::new_from_blame_line(line)?;
-
-                if let Some(existing_entry) = index
-                    .get(&new_entry.sha)
-                    .and_then(|slot| entries.get(*slot))
-                {
-                    new_entry.author.clone_from(&existing_entry.author);
-                    new_entry
-                        .author_mail
-                        .clone_from(&existing_entry.author_mail);
-                    new_entry.author_time = existing_entry.author_time;
-                    new_entry.author_tz.clone_from(&existing_entry.author_tz);
-                    new_entry
-                        .committer_name
-                        .clone_from(&existing_entry.committer_name);
-                    new_entry
-                        .committer_email
-                        .clone_from(&existing_entry.committer_email);
-                    new_entry.committer_time = existing_entry.committer_time;
-                    new_entry
-                        .committer_tz
-                        .clone_from(&existing_entry.committer_tz);
-                    new_entry.summary.clone_from(&existing_entry.summary);
-                }
-
-                current_entry.replace(new_entry);
-            }
-            Some(entry) => {
-                let Some((key, value)) = line.split_once(' ') else {
-                    continue;
-                };
-                let is_committed = !entry.sha.is_zero();
-                match key {
-                    "filename" => {
-                        entry.filename = value.into();
-                        done = true;
-                    }
-                    "previous" => entry.previous = Some(value.into()),
-
-                    "summary" if is_committed => entry.summary = Some(value.into()),
-                    "author" if is_committed => entry.author = Some(value.into()),
-                    "author-mail" if is_committed => entry.author_mail = Some(value.into()),
-                    "author-time" if is_committed => {
-                        entry.author_time = Some(value.parse::<i64>()?)
-                    }
-                    "author-tz" if is_committed => entry.author_tz = Some(value.into()),
-
-                    "committer" if is_committed => entry.committer_name = Some(value.into()),
-                    "committer-mail" if is_committed => entry.committer_email = Some(value.into()),
-                    "committer-time" if is_committed => {
-                        entry.committer_time = Some(value.parse::<i64>()?)
-                    }
-                    "committer-tz" if is_committed => entry.committer_tz = Some(value.into()),
-                    _ => {}
-                }
-            }
-        };
-
-        if done {
-            if let Some(entry) = current_entry.take() {
-                index.insert(entry.sha, entries.len());
-
-                // We only want annotations that have a commit.
-                if !entry.sha.is_zero() {
-                    entries.push(entry);
-                }
-            }
-        }
-    }
-
-    Ok(entries)
-}
-
-#[cfg(test)]
-mod tests {
-    use std::path::PathBuf;
-
-    use super::BlameEntry;
-    use super::parse_git_blame;
-
-    fn read_test_data(filename: &str) -> String {
-        let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-        path.push("test_data");
-        path.push(filename);
-
-        std::fs::read_to_string(&path)
-            .unwrap_or_else(|_| panic!("Could not read test data at {:?}. Is it generated?", path))
-    }
-
-    fn assert_eq_golden(entries: &Vec<BlameEntry>, golden_filename: &str) {
-        let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-        path.push("test_data");
-        path.push("golden");
-        path.push(format!("{}.json", golden_filename));
-
-        let mut have_json =
-            serde_json::to_string_pretty(&entries).expect("could not serialize entries to JSON");
-        // We always want to save with a trailing newline.
-        have_json.push('\n');
-
-        let update = std::env::var("UPDATE_GOLDEN")
-            .map(|val| val.eq_ignore_ascii_case("true"))
-            .unwrap_or(false);
-
-        if update {
-            std::fs::create_dir_all(path.parent().unwrap())
-                .expect("could not create golden test data directory");
-            std::fs::write(&path, have_json).expect("could not write out golden data");
-        } else {
-            let want_json =
-                std::fs::read_to_string(&path).unwrap_or_else(|_| {
-                    panic!("could not read golden test data file at {:?}. Did you run the test with UPDATE_GOLDEN=true before?", path);
-                }).replace("\r\n", "\n");
-
-            pretty_assertions::assert_eq!(have_json, want_json, "wrong blame entries");
-        }
-    }
-
-    #[test]
-    fn test_parse_git_blame_not_committed() {
-        let output = read_test_data("blame_incremental_not_committed");
-        let entries = parse_git_blame(&output).unwrap();
-        assert_eq_golden(&entries, "blame_incremental_not_committed");
-    }
-
-    #[test]
-    fn test_parse_git_blame_simple() {
-        let output = read_test_data("blame_incremental_simple");
-        let entries = parse_git_blame(&output).unwrap();
-        assert_eq_golden(&entries, "blame_incremental_simple");
-    }
-
-    #[test]
-    fn test_parse_git_blame_complex() {
-        let output = read_test_data("blame_incremental_complex");
-        let entries = parse_git_blame(&output).unwrap();
-        assert_eq_golden(&entries, "blame_incremental_complex");
-    }
-}

crates/assistant_tools/src/grep_tool.rs

@@ -314,7 +314,7 @@ impl Tool for GrepTool {
 mod tests {
     use super::*;
     use assistant_tool::Tool;
-    use gpui::{TestAppContext, UpdateGlobal};
+    use gpui::{AppContext, TestAppContext, UpdateGlobal};
     use language::{Language, LanguageConfig, LanguageMatcher};
     use language_model::fake_provider::FakeLanguageModel;
     use project::{FakeFs, Project, WorktreeSettings};

crates/assistant_tools/src/list_directory_tool.rs

@@ -226,7 +226,7 @@ impl Tool for ListDirectoryTool {
 mod tests {
     use super::*;
     use assistant_tool::Tool;
-    use gpui::{TestAppContext, UpdateGlobal};
+    use gpui::{AppContext, TestAppContext, UpdateGlobal};
     use indoc::indoc;
     use language_model::fake_provider::FakeLanguageModel;
     use project::{FakeFs, Project, WorktreeSettings};

crates/assistant_tools/src/read_file_tool.rs

@@ -289,7 +289,7 @@ impl Tool for ReadFileTool {
 #[cfg(test)]
 mod test {
     use super::*;
-    use gpui::{TestAppContext, UpdateGlobal};
+    use gpui::{AppContext, TestAppContext, UpdateGlobal};
     use language::{Language, LanguageConfig, LanguageMatcher};
     use language_model::fake_provider::FakeLanguageModel;
     use project::{FakeFs, Project, WorktreeSettings};

crates/assistant_tools/src/schema.rs

@@ -22,7 +22,7 @@ fn schema_to_json(
     Ok(value)
 }
 
-pub fn root_schema_for<T: JsonSchema>(format: LanguageModelToolSchemaFormat) -> Schema {
+fn root_schema_for<T: JsonSchema>(format: LanguageModelToolSchemaFormat) -> Schema {
     let mut generator = match format {
         LanguageModelToolSchemaFormat::JsonSchema => SchemaSettings::draft07().into_generator(),
         // TODO: Gemini docs mention using a subset of OpenAPI 3, so this may benefit from using

crates/assistant_tools/src/templates/edit_agent.hbs

@@ -1,47 +0,0 @@
-You are an expert text editor. Taking the following file as an input:
-
-```{{path}}
-{{file_content}}
-```
-
-Produce a series of edits following the given user instructions:
-
-<user_instructions>
-{{instructions}}
-</user_instructions>
-
-Your response must be a series of edits in the following format:
-
-<edits>
-<old_text>
-OLD TEXT 1 HERE
-</old_text>
-<new_text>
-NEW TEXT 1 HERE
-</new_text>
-
-<old_text>
-OLD TEXT 2 HERE
-</old_text>
-<new_text>
-NEW TEXT 2 HERE
-</new_text>
-
-<old_text>
-OLD TEXT 3 HERE
-</old_text>
-<new_text>
-NEW TEXT 3 HERE
-</new_text>
-</edits>
-
-Rules for editing:
-
-- `old_text` represents full lines (including indentation) in the input file that will be replaced with `new_text`
-- It is crucial that `old_text` is unique and unambiguous.
-- Always include enough context around the lines you want to replace in `old_text` such that it's impossible to mistake them for other lines.
-- If you want to replace all occurrences, repeat the same `old_text`/`new_text` pair multiple times and I will apply them sequentially, one occurrence at a time.
-- Don't explain why you made a change, just report the edits.
-- Make sure you follow the instructions carefully and thoroughly, avoid doing *less* or *more* than instructed.
-
-<edits>

crates/collab/src/tests/remote_editing_collaboration_tests.rs

@@ -6,7 +6,10 @@ use debugger_ui::debugger_panel::DebugPanel;
 use extension::ExtensionHostProxy;
 use fs::{FakeFs, Fs as _, RemoveOptions};
 use futures::StreamExt as _;
-use gpui::{BackgroundExecutor, SemanticVersion, TestAppContext, UpdateGlobal as _, VisualContext};
+use gpui::{
+    AppContext as _, BackgroundExecutor, SemanticVersion, TestAppContext, UpdateGlobal as _,
+    VisualContext,
+};
 use http_client::BlockedHttpClient;
 use language::{
     FakeLspAdapter, Language, LanguageConfig, LanguageMatcher, LanguageRegistry,

crates/dap_adapters/Cargo.toml

@@ -25,7 +25,9 @@ anyhow.workspace = true
 async-trait.workspace = true
 collections.workspace = true
 dap.workspace = true
+dotenvy.workspace = true
 futures.workspace = true
+fs.workspace = true
 gpui.workspace = true
 json_dotpath.workspace = true
 language.workspace = true

crates/dap_adapters/src/go.rs

@@ -7,13 +7,22 @@ use dap::{
         latest_github_release,
     },
 };
-
+use fs::Fs;
 use gpui::{AsyncApp, SharedString};
 use language::LanguageName;
-use std::{env::consts, ffi::OsStr, path::PathBuf, sync::OnceLock};
+use log::warn;
+use serde_json::{Map, Value};
 use task::TcpArgumentsTemplate;
 use util;
 
+use std::{
+    env::consts,
+    ffi::OsStr,
+    path::{Path, PathBuf},
+    str::FromStr,
+    sync::OnceLock,
+};
+
 use crate::*;
 
 #[derive(Default, Debug)]
@@ -437,22 +446,34 @@ impl DebugAdapter for GoDebugAdapter {
             adapter_path.join("dlv").to_string_lossy().to_string()
         };
 
-        let cwd = task_definition
-            .config
-            .get("cwd")
-            .and_then(|s| s.as_str())
-            .map(PathBuf::from)
-            .unwrap_or_else(|| delegate.worktree_root_path().to_path_buf());
+        let cwd = Some(
+            task_definition
+                .config
+                .get("cwd")
+                .and_then(|s| s.as_str())
+                .map(PathBuf::from)
+                .unwrap_or_else(|| delegate.worktree_root_path().to_path_buf()),
+        );
 
         let arguments;
         let command;
         let connection;
 
         let mut configuration = task_definition.config.clone();
+        let mut envs = HashMap::default();
+
         if let Some(configuration) = configuration.as_object_mut() {
             configuration
                 .entry("cwd")
                 .or_insert_with(|| delegate.worktree_root_path().to_string_lossy().into());
+
+            handle_envs(
+                configuration,
+                &mut envs,
+                cwd.as_deref(),
+                delegate.fs().clone(),
+            )
+            .await;
         }
 
         if let Some(connection_options) = &task_definition.tcp_connection {
@@ -494,8 +515,8 @@ impl DebugAdapter for GoDebugAdapter {
         Ok(DebugAdapterBinary {
             command,
             arguments,
-            cwd: Some(cwd),
-            envs: HashMap::default(),
+            cwd,
+            envs,
             connection,
             request_args: StartDebuggingRequestArguments {
                 configuration,
@@ -504,3 +525,44 @@ impl DebugAdapter for GoDebugAdapter {
         })
     }
 }
+
+// delve doesn't do anything with the envFile setting, so we intercept it
+async fn handle_envs(
+    config: &mut Map<String, Value>,
+    envs: &mut HashMap<String, String>,
+    cwd: Option<&Path>,
+    fs: Arc<dyn Fs>,
+) -> Option<()> {
+    let env_files = match config.get("envFile")? {
+        Value::Array(arr) => arr.iter().map(|v| v.as_str()).collect::<Vec<_>>(),
+        Value::String(s) => vec![Some(s.as_str())],
+        _ => return None,
+    };
+
+    let rebase_path = |path: PathBuf| {
+        if path.is_absolute() {
+            Some(path)
+        } else {
+            cwd.map(|p| p.join(path))
+        }
+    };
+
+    for path in env_files {
+        let Some(path) = path
+            .and_then(|s| PathBuf::from_str(s).ok())
+            .and_then(rebase_path)
+        else {
+            continue;
+        };
+
+        if let Ok(file) = fs.open_sync(&path).await {
+            envs.extend(dotenvy::from_read_iter(file).filter_map(Result::ok))
+        } else {
+            warn!("While starting Go debug session: failed to read env file {path:?}");
+        };
+    }
+
+    // remove envFile now that it's been handled
+    config.remove("entry");
+    Some(())
+}

crates/editor/src/inlay_hint_cache.rs

@@ -1307,7 +1307,7 @@ pub mod tests {
     use crate::scroll::ScrollAmount;
     use crate::{ExcerptRange, scroll::Autoscroll, test::editor_lsp_test_context::rust_lang};
     use futures::StreamExt;
-    use gpui::{Context, SemanticVersion, TestAppContext, WindowHandle};
+    use gpui::{AppContext as _, Context, SemanticVersion, TestAppContext, WindowHandle};
     use itertools::Itertools as _;
     use language::{Capability, FakeLspAdapter, language_settings::AllLanguageSettingsContent};
     use language::{Language, LanguageConfig, LanguageMatcher};

crates/editor/src/jsx_tag_auto_close.rs

@@ -626,7 +626,7 @@ mod jsx_tag_autoclose_tests {
     };
 
     use super::*;
-    use gpui::TestAppContext;
+    use gpui::{AppContext as _, TestAppContext};
     use language::language_settings::JsxTagAutoCloseSettings;
     use languages::language;
     use multi_buffer::ExcerptRange;

crates/eval/Cargo.toml

@@ -32,7 +32,7 @@ client.workspace = true
 collections.workspace = true
 debug_adapter_extension.workspace = true
 dirs.workspace = true
-dotenv.workspace = true
+dotenvy.workspace = true
 env_logger.workspace = true
 extension.workspace = true
 fs.workspace = true

crates/eval/src/eval.rs

@@ -63,7 +63,7 @@ struct Args {
 }
 
 fn main() {
-    dotenv::from_filename(CARGO_MANIFEST_DIR.join(".env")).ok();
+    dotenvy::from_filename(CARGO_MANIFEST_DIR.join(".env")).ok();
 
     env_logger::init();
 

crates/eval/src/examples/edit.rs

@@ -1,3 +0,0 @@
-pub mod basic;
-
-pub use basic::*;

crates/eval/src/examples/edit/basic.rs

@@ -1,104 +0,0 @@
-use std::{collections::HashSet, path::Path, sync::Arc};
-
-use anyhow::Result;
-use assistant_tools::{CreateFileToolInput, EditFileToolInput, ReadFileToolInput};
-use async_trait::async_trait;
-use buffer_diff::DiffHunkStatus;
-use collections::HashMap;
-
-use crate::example::{
-    Example, ExampleContext, ExampleMetadata, FileEditHunk, FileEdits, JudgeAssertion,
-    LanguageServer,
-};
-
-pub struct EditBasic;
-
-#[async_trait(?Send)]
-impl Example for EditBasic {
-    fn meta(&self) -> ExampleMetadata {
-        ExampleMetadata {
-            name: "edit_basic".to_string(),
-            url: "https://github.com/zed-industries/zed.git".to_string(),
-            revision: "58604fba86ebbffaa01f7c6834253e33bcd38c0f".to_string(),
-            language_server: None,
-            max_assertions: None,
-        }
-    }
-
-    async fn conversation(&self, cx: &mut ExampleContext) -> Result<()> {
-        cx.push_user_message(format!(
-            r#"
-            Read the `crates/git/src/blame.rs` file and delete `run_git_blame`. Just that
-            one function, not its usages.
-
-            IMPORTANT: You are only allowed to use the `read_file` and `edit_file` tools!
-            "#
-        ));
-
-        let response = cx.run_to_end().await?;
-        // let expected_edits = HashMap::from_iter([(
-        //     Arc::from(Path::new("crates/git/src/blame.rs")),
-        //     FileEdits {
-        //         hunks: vec![
-        //             FileEditHunk {
-        //                 base_text: "            unique_shas.insert(entry.sha);\n".into(),
-        //                 text: "            unique_shas.insert(entry.git_sha);\n".into(),
-        //                 status: DiffHunkStatus::modified_none(),
-        //             },
-        //             FileEditHunk {
-        //                 base_text: "    pub sha: Oid,\n".into(),
-        //                 text: "    pub git_sha: Oid,\n".into(),
-        //                 status: DiffHunkStatus::modified_none(),
-        //             },
-        //             FileEditHunk {
-        //                 base_text: "        let sha = parts\n".into(),
-        //                 text: "        let git_sha = parts\n".into(),
-        //                 status: DiffHunkStatus::modified_none(),
-        //             },
-        //             FileEditHunk {
-        //                 base_text:
-        //                     "            .ok_or_else(|| anyhow!(\"failed to parse sha\"))?;\n"
-        //                         .into(),
-        //                 text:
-        //                     "            .ok_or_else(|| anyhow!(\"failed to parse git_sha\"))?;\n"
-        //                         .into(),
-        //                 status: DiffHunkStatus::modified_none(),
-        //             },
-        //             FileEditHunk {
-        //                 base_text: "            sha,\n".into(),
-        //                 text: "            git_sha,\n".into(),
-        //                 status: DiffHunkStatus::modified_none(),
-        //             },
-        //             FileEditHunk {
-        //                 base_text: "                    .get(&new_entry.sha)\n".into(),
-        //                 text: "                    .get(&new_entry.git_sha)\n".into(),
-        //                 status: DiffHunkStatus::modified_none(),
-        //             },
-        //             FileEditHunk {
-        //                 base_text: "                let is_committed = !entry.sha.is_zero();\n"
-        //                     .into(),
-        //                 text: "                let is_committed = !entry.git_sha.is_zero();\n"
-        //                     .into(),
-        //                 status: DiffHunkStatus::modified_none(),
-        //             },
-        //             FileEditHunk {
-        //                 base_text: "                index.insert(entry.sha, entries.len());\n"
-        //                     .into(),
-        //                 text: "                index.insert(entry.git_sha, entries.len());\n"
-        //                     .into(),
-        //                 status: DiffHunkStatus::modified_none(),
-        //             },
-        //             FileEditHunk {
-        //                 base_text: "                if !entry.sha.is_zero() {\n".into(),
-        //                 text: "                if !entry.git_sha.is_zero() {\n".into(),
-        //                 status: DiffHunkStatus::modified_none(),
-        //             },
-        //         ],
-        //     },
-        // )]);
-        // let actual_edits = cx.edits();
-        // cx.assert_eq(&actual_edits, &expected_edits, "edits don't match")?;
-
-        Ok(())
-    }
-}

crates/extension_host/src/extension_store_test.rs

@@ -8,7 +8,7 @@ use collections::{BTreeMap, HashSet};
 use extension::ExtensionHostProxy;
 use fs::{FakeFs, Fs, RealFs};
 use futures::{AsyncReadExt, StreamExt, io::BufReader};
-use gpui::{SemanticVersion, TestAppContext};
+use gpui::{AppContext as _, SemanticVersion, TestAppContext};
 use http_client::{FakeHttpClient, Response};
 use language::{BinaryStatus, LanguageMatcher, LanguageRegistry};
 use lsp::LanguageServerName;

crates/extensions_ui/src/extension_suggest.rs

@@ -70,6 +70,7 @@ const SUGGESTIONS_BY_EXTENSION_ID: &[(&str, &[&str])] = &[
     ("templ", &["templ"]),
     ("terraform", &["tf", "tfvars", "hcl"]),
     ("toml", &["Cargo.lock", "toml"]),
+    ("typst", &["typ"]),
     ("vue", &["vue"]),
     ("wgsl", &["wgsl"]),
     ("wit", &["wit"]),

crates/gpui/src/app.rs

@@ -1069,7 +1069,7 @@ impl App {
         }
     }
 
-    /// Obtains a reference to the background executor, which can be used to spawn futures.
+    /// Obtains a reference to the executor, which can be used to spawn futures.
     pub fn background_executor(&self) -> &BackgroundExecutor {
         &self.background_executor
     }

crates/gpui/src/app/test_context.rs

@@ -178,14 +178,7 @@ impl TestAppContext {
         &self.foreground_executor
     }
 
-    /// Builds an entity that is owned by the application.
-    ///
-    /// The given function will be invoked with a [`Context`] and must return an object representing the entity. An
-    /// [`Entity`] handle will be returned, which can be used to access the entity in a context.
-    pub fn new<T: 'static>(
-        &mut self,
-        build_entity: impl FnOnce(&mut Context<T>) -> T,
-    ) -> Entity<T> {
+    fn new<T: 'static>(&mut self, build_entity: impl FnOnce(&mut Context<T>) -> T) -> Entity<T> {
         let mut cx = self.app.borrow_mut();
         cx.new(build_entity)
     }

crates/gpui/src/executor.rs

@@ -95,13 +95,6 @@ where
             .spawn(self.log_tracked_err(*location))
             .detach();
     }
-
-    /// Convert a Task<Result<T, E>> to a Task<()> that logs all errors.
-    pub fn log_err_in_task(self, cx: &App) -> Task<Option<T>> {
-        let location = core::panic::Location::caller();
-        cx.foreground_executor()
-            .spawn(async move { self.log_tracked_err(*location).await })
-    }
 }
 
 impl<T> Future for Task<T> {

crates/language_model/src/language_model.rs

@@ -91,7 +91,6 @@ pub enum LanguageModelCompletionEvent {
     },
     StartMessage {
         message_id: String,
-        role: Role,
     },
     UsageUpdate(TokenUsage),
 }
@@ -501,7 +500,7 @@ pub trait LanguageModel: Send + Sync {
 
             if let Some(first_event) = events.next().await {
                 match first_event {
-                    Ok(LanguageModelCompletionEvent::StartMessage { message_id: id, .. }) => {
+                    Ok(LanguageModelCompletionEvent::StartMessage { message_id: id }) => {
                         message_id = Some(id.clone());
                     }
                     Ok(LanguageModelCompletionEvent::Text(text)) => {

crates/language_model/src/request.rs

@@ -12,7 +12,7 @@ use gpui::{
 use image::codecs::png::PngEncoder;
 use serde::{Deserialize, Serialize};
 use util::ResultExt;
-pub use zed_llm_client::{CompletionIntent, CompletionMode};
+use zed_llm_client::{CompletionIntent, CompletionMode};
 
 #[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Hash)]
 pub struct LanguageModelImage {
@@ -344,24 +344,6 @@ impl From<&str> for MessageContent {
     }
 }
 
-impl From<LanguageModelToolUse> for MessageContent {
-    fn from(value: LanguageModelToolUse) -> Self {
-        MessageContent::ToolUse(value)
-    }
-}
-
-impl From<LanguageModelImage> for MessageContent {
-    fn from(value: LanguageModelImage) -> Self {
-        MessageContent::Image(value)
-    }
-}
-
-impl From<LanguageModelToolResult> for MessageContent {
-    fn from(value: LanguageModelToolResult) -> Self {
-        MessageContent::ToolResult(value)
-    }
-}
-
 #[derive(Clone, Serialize, Deserialize, Debug, PartialEq, Hash)]
 pub struct LanguageModelRequestMessage {
     pub role: Role,

crates/language_model/src/role.rs

@@ -36,29 +36,6 @@ impl Role {
     }
 }
 
-impl From<anthropic::Role> for Role {
-    fn from(role: anthropic::Role) -> Self {
-        match role {
-            anthropic::Role::User => Role::User,
-            anthropic::Role::Assistant => Role::Assistant,
-        }
-    }
-}
-
-impl TryFrom<Role> for anthropic::Role {
-    type Error = anyhow::Error;
-
-    fn try_from(role: Role) -> Result<Self, Self::Error> {
-        match role {
-            Role::User => Ok(anthropic::Role::User),
-            Role::Assistant => Ok(anthropic::Role::Assistant),
-            Role::System => Err(anyhow::anyhow!(
-                "System role is not supported in anthropic API"
-            )),
-        }
-    }
-}
-
 impl Display for Role {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> std::fmt::Result {
         match self {

crates/language_models/src/provider/anthropic.rs

@@ -833,7 +833,6 @@ impl AnthropicEventMapper {
                     ))),
                     Ok(LanguageModelCompletionEvent::StartMessage {
                         message_id: message.id,
-                        role: message.role.into(),
                     }),
                 ]
             }

crates/language_models/src/provider/cloud.rs

@@ -1057,7 +1057,7 @@ fn response_lines<T: DeserializeOwned>(
 }
 
 #[derive(IntoElement, RegisterComponent)]
-struct ZedAIConfiguration {
+struct ZedAiConfiguration {
     is_connected: bool,
     plan: Option<proto::Plan>,
     subscription_period: Option<(DateTime<Utc>, DateTime<Utc>)>,
@@ -1068,7 +1068,7 @@ struct ZedAIConfiguration {
     sign_in_callback: Arc<dyn Fn(&mut Window, &mut App) + Send + Sync>,
 }
 
-impl RenderOnce for ZedAIConfiguration {
+impl RenderOnce for ZedAiConfiguration {
     fn render(self, _window: &mut Window, _cx: &mut App) -> impl IntoElement {
         const ZED_PRICING_URL: &str = "https://zed.dev/pricing";
 
@@ -1195,7 +1195,7 @@ impl Render for ConfigurationView {
         let state = self.state.read(cx);
         let user_store = state.user_store.read(cx);
 
-        ZedAIConfiguration {
+        ZedAiConfiguration {
             is_connected: !state.is_signed_out(),
             plan: user_store.current_plan(),
             subscription_period: user_store.subscription_period(),
@@ -1208,7 +1208,7 @@ impl Render for ConfigurationView {
     }
 }
 
-impl Component for ZedAIConfiguration {
+impl Component for ZedAiConfiguration {
     fn scope() -> ComponentScope {
         ComponentScope::Agent
     }
@@ -1220,7 +1220,7 @@ impl Component for ZedAIConfiguration {
             eligible_for_trial: bool,
             has_accepted_terms_of_service: bool,
         ) -> AnyElement {
-            ZedAIConfiguration {
+            ZedAiConfiguration {
                 is_connected,
                 plan,
                 subscription_period: plan

crates/language_tools/src/lsp_log_tests.rs

@@ -4,7 +4,7 @@ use crate::lsp_log::LogMenuItem;
 
 use super::*;
 use futures::StreamExt;
-use gpui::{SemanticVersion, TestAppContext, VisualTestContext};
+use gpui::{AppContext as _, SemanticVersion, TestAppContext, VisualTestContext};
 use language::{FakeLspAdapter, Language, LanguageConfig, LanguageMatcher, tree_sitter_rust};
 use lsp::LanguageServerName;
 use lsp_log::LogKind;

crates/languages/src/bash.rs

@@ -18,7 +18,7 @@ pub(super) fn bash_task_context() -> ContextProviderWithTasks {
 
 #[cfg(test)]
 mod tests {
-    use gpui::{BorrowAppContext, Context, TestAppContext};
+    use gpui::{AppContext as _, BorrowAppContext, Context, TestAppContext};
     use language::{AutoindentMode, Buffer, language_settings::AllLanguageSettings};
     use settings::SettingsStore;
     use std::num::NonZeroU32;

crates/languages/src/c.rs

@@ -347,7 +347,7 @@ async fn get_cached_server_binary(container_dir: PathBuf) -> Option<LanguageServ
 
 #[cfg(test)]
 mod tests {
-    use gpui::{BorrowAppContext, TestAppContext};
+    use gpui::{AppContext as _, BorrowAppContext, TestAppContext};
     use language::{AutoindentMode, Buffer, language_settings::AllLanguageSettings};
     use settings::SettingsStore;
     use std::num::NonZeroU32;

crates/languages/src/css.rs

@@ -167,7 +167,7 @@ async fn get_cached_server_binary(
 
 #[cfg(test)]
 mod tests {
-    use gpui::TestAppContext;
+    use gpui::{AppContext as _, TestAppContext};
     use unindent::Unindent;
 
     #[gpui::test]

crates/languages/src/python.rs

@@ -1286,7 +1286,7 @@ impl LspAdapter for PyLspAdapter {
 
 #[cfg(test)]
 mod tests {
-    use gpui::{BorrowAppContext, Context, TestAppContext};
+    use gpui::{AppContext as _, BorrowAppContext, Context, TestAppContext};
     use language::{AutoindentMode, Buffer, language_settings::AllLanguageSettings};
     use settings::SettingsStore;
     use std::num::NonZeroU32;

crates/languages/src/python/highlights.scm

@@ -226,6 +226,12 @@
   ">>"
   "|"
   "~"
+  "&="
+  "<<="
+  ">>="
+  "@="
+  "^="
+  "|="
 ] @operator
 
 [

crates/languages/src/typescript.rs

@@ -1010,7 +1010,7 @@ async fn handle_symlink(src_dir: PathBuf, dest_dir: PathBuf) -> Result<()> {
 mod tests {
     use std::path::Path;
 
-    use gpui::{BackgroundExecutor, TestAppContext};
+    use gpui::{AppContext as _, BackgroundExecutor, TestAppContext};
     use language::language_settings;
     use project::{FakeFs, Project};
     use serde_json::json;

crates/migrator/src/migrations.rs

@@ -82,12 +82,6 @@ pub(crate) mod m_2025_06_16 {
     pub(crate) use settings::SETTINGS_PATTERNS;
 }
 
-pub(crate) mod m_2025_06_25 {
-    mod settings;
-
-    pub(crate) use settings::SETTINGS_PATTERNS;
-}
-
 pub(crate) mod m_2025_06_27 {
     mod settings;
 

crates/migrator/src/migrations/m_2025_06_25/settings.rs

@@ -1,133 +0,0 @@
-use std::ops::Range;
-use tree_sitter::{Query, QueryMatch};
-
-use crate::MigrationPatterns;
-
-pub const SETTINGS_PATTERNS: MigrationPatterns = &[
-    (SETTINGS_VERSION_PATTERN, remove_version_fields),
-    (
-        SETTINGS_NESTED_VERSION_PATTERN,
-        remove_nested_version_fields,
-    ),
-];
-
-const SETTINGS_VERSION_PATTERN: &str = r#"(document
-    (object
-        (pair
-            key: (string (string_content) @key)
-            value: (object
-                (pair
-                    key: (string (string_content) @version_key)
-                    value: (_) @version_value
-                ) @version_pair
-            )
-        )
-    )
-    (#eq? @key "agent")
-    (#eq? @version_key "version")
-)"#;
-
-const SETTINGS_NESTED_VERSION_PATTERN: &str = r#"(document
-    (object
-        (pair
-            key: (string (string_content) @language_models)
-            value: (object
-                (pair
-                    key: (string (string_content) @provider)
-                    value: (object
-                        (pair
-                            key: (string (string_content) @version_key)
-                            value: (_) @version_value
-                        ) @version_pair
-                    )
-                )
-            )
-        )
-    )
-    (#eq? @language_models "language_models")
-    (#match? @provider "^(anthropic|openai)$")
-    (#eq? @version_key "version")
-)"#;
-
-fn remove_version_fields(
-    contents: &str,
-    mat: &QueryMatch,
-    query: &Query,
-) -> Option<(Range<usize>, String)> {
-    let version_pair_ix = query.capture_index_for_name("version_pair")?;
-    let version_pair_node = mat.nodes_for_capture_index(version_pair_ix).next()?;
-
-    remove_pair_with_whitespace(contents, version_pair_node)
-}
-
-fn remove_nested_version_fields(
-    contents: &str,
-    mat: &QueryMatch,
-    query: &Query,
-) -> Option<(Range<usize>, String)> {
-    let version_pair_ix = query.capture_index_for_name("version_pair")?;
-    let version_pair_node = mat.nodes_for_capture_index(version_pair_ix).next()?;
-
-    remove_pair_with_whitespace(contents, version_pair_node)
-}
-
-fn remove_pair_with_whitespace(
-    contents: &str,
-    pair_node: tree_sitter::Node,
-) -> Option<(Range<usize>, String)> {
-    let mut range_to_remove = pair_node.byte_range();
-
-    // Check if there's a comma after this pair
-    if let Some(next_sibling) = pair_node.next_sibling() {
-        if next_sibling.kind() == "," {
-            range_to_remove.end = next_sibling.end_byte();
-        }
-    } else {
-        // If no next sibling, check if there's a comma before
-        if let Some(prev_sibling) = pair_node.prev_sibling() {
-            if prev_sibling.kind() == "," {
-                range_to_remove.start = prev_sibling.start_byte();
-            }
-        }
-    }
-
-    // Include any leading whitespace/newline, including comments
-    let text_before = &contents[..range_to_remove.start];
-    if let Some(last_newline) = text_before.rfind('\n') {
-        let whitespace_start = last_newline + 1;
-        let potential_whitespace = &contents[whitespace_start..range_to_remove.start];
-
-        // Check if it's only whitespace or comments
-        let mut is_whitespace_or_comment = true;
-        let mut in_comment = false;
-        let mut chars = potential_whitespace.chars().peekable();
-
-        while let Some(ch) = chars.next() {
-            if in_comment {
-                if ch == '\n' {
-                    in_comment = false;
-                }
-            } else if ch == '/' && chars.peek() == Some(&'/') {
-                in_comment = true;
-                chars.next(); // Skip the second '/'
-            } else if !ch.is_whitespace() {
-                is_whitespace_or_comment = false;
-                break;
-            }
-        }
-
-        if is_whitespace_or_comment {
-            range_to_remove.start = whitespace_start;
-        }
-    }
-
-    // Also check if we need to include trailing whitespace up to the next line
-    let text_after = &contents[range_to_remove.end..];
-    if let Some(newline_pos) = text_after.find('\n') {
-        if text_after[..newline_pos].chars().all(|c| c.is_whitespace()) {
-            range_to_remove.end += newline_pos + 1;
-        }
-    }
-
-    Some((range_to_remove, String::new()))
-}

crates/migrator/src/migrator.rs

@@ -152,10 +152,6 @@ pub fn migrate_settings(text: &str) -> Result<Option<String>> {
             migrations::m_2025_06_16::SETTINGS_PATTERNS,
             &SETTINGS_QUERY_2025_06_16,
         ),
-        (
-            migrations::m_2025_06_25::SETTINGS_PATTERNS,
-            &SETTINGS_QUERY_2025_06_25,
-        ),
         (
             migrations::m_2025_06_27::SETTINGS_PATTERNS,
             &SETTINGS_QUERY_2025_06_27,
@@ -262,10 +258,6 @@ define_query!(
     SETTINGS_QUERY_2025_06_16,
     migrations::m_2025_06_16::SETTINGS_PATTERNS
 );
-define_query!(
-    SETTINGS_QUERY_2025_06_25,
-    migrations::m_2025_06_25::SETTINGS_PATTERNS
-);
 define_query!(
     SETTINGS_QUERY_2025_06_27,
     migrations::m_2025_06_27::SETTINGS_PATTERNS
@@ -1089,77 +1081,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn test_remove_version_fields() {
-        assert_migrate_settings(
-            r#"{
-    "language_models": {
-        "anthropic": {
-            "version": "1",
-            "api_url": "https://api.anthropic.com"
-        },
-        "openai": {
-            "version": "1",
-            "api_url": "https://api.openai.com/v1"
-        }
-    },
-    "agent": {
-        "version": "2",
-        "enabled": true,
-        "preferred_completion_mode": "normal",
-        "button": true,
-        "dock": "right",
-        "default_width": 640,
-        "default_height": 320,
-        "default_model": {
-            "provider": "zed.dev",
-            "model": "claude-sonnet-4"
-        }
-    }
-}"#,
-            Some(
-                r#"{
-    "language_models": {
-        "anthropic": {
-            "api_url": "https://api.anthropic.com"
-        },
-        "openai": {
-            "api_url": "https://api.openai.com/v1"
-        }
-    },
-    "agent": {
-        "enabled": true,
-        "preferred_completion_mode": "normal",
-        "button": true,
-        "dock": "right",
-        "default_width": 640,
-        "default_height": 320,
-        "default_model": {
-            "provider": "zed.dev",
-            "model": "claude-sonnet-4"
-        }
-    }
-}"#,
-            ),
-        );
-
-        // Test that version fields in other contexts are not removed
-        assert_migrate_settings(
-            r#"{
-    "language_models": {
-        "other_provider": {
-            "version": "1",
-            "api_url": "https://api.example.com"
-        }
-    },
-    "other_section": {
-        "version": "1"
-    }
-}"#,
-            None,
-        );
-    }
-
     #[test]
     fn test_flatten_context_server_command() {
         assert_migrate_settings(

crates/project/src/context_server_store.rs

@@ -593,7 +593,7 @@ mod tests {
         project_settings::ProjectSettings,
     };
     use context_server::test::create_fake_transport;
-    use gpui::{TestAppContext, UpdateGlobal as _};
+    use gpui::{AppContext, TestAppContext, UpdateGlobal as _};
     use serde_json::json;
     use std::{cell::RefCell, rc::Rc};
     use util::path;

crates/storybook/src/stories.rs

@@ -1,6 +1,7 @@
 mod auto_height_editor;
 mod cursor;
 mod focus;
+mod indent_guides;
 mod kitchen_sink;
 mod overflow_scroll;
 mod picker;
@@ -12,6 +13,7 @@ mod with_rem_size;
 pub use auto_height_editor::*;
 pub use cursor::*;
 pub use focus::*;
+pub use indent_guides::*;
 pub use kitchen_sink::*;
 pub use overflow_scroll::*;
 pub use picker::*;

crates/storybook/src/stories/indent_guides.rs

@@ -1,13 +1,10 @@
-use std::fmt::format;
+use std::ops::Range;
+
+use gpui::{Entity, Render, div, uniform_list};
+use gpui::{prelude::*, *};
+use ui::{AbsoluteLength, Color, DefiniteLength, Label, LabelCommon, px, v_flex};
 
-use gpui::{
-    DefaultColor, DefaultThemeAppearance, Hsla, Render, colors, div, prelude::*, uniform_list,
-};
 use story::Story;
-use strum::IntoEnumIterator;
-use ui::{
-    AbsoluteLength, ActiveTheme, Color, DefiniteLength, Label, LabelCommon, h_flex, px, v_flex,
-};
 
 const LENGTH: usize = 100;
 
@@ -16,7 +13,7 @@ pub struct IndentGuidesStory {
 }
 
 impl IndentGuidesStory {
-    pub fn model(window: &mut Window, cx: &mut AppContext) -> Model<Self> {
+    pub fn model(_window: &mut Window, cx: &mut App) -> Entity<Self> {
         let mut depths = Vec::new();
         depths.push(0);
         depths.push(1);
@@ -33,16 +30,15 @@ impl IndentGuidesStory {
 }
 
 impl Render for IndentGuidesStory {
-    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
         Story::container(cx)
-            .child(Story::title("Indent guides"))
+            .child(Story::title("Indent guides", cx))
             .child(
                 v_flex().size_full().child(
                     uniform_list(
-                        cx.entity().clone(),
                         "some-list",
                         self.depths.len(),
-                        |this, range, cx| {
+                        cx.processor(move |this, range: Range<usize>, _window, _cx| {
                             this.depths
                                 .iter()
                                 .enumerate()
@@ -56,7 +52,7 @@ impl Render for IndentGuidesStory {
                                         .child(Label::new(format!("Item {}", i)).color(Color::Info))
                                 })
                                 .collect()
-                        },
+                        }),
                     )
                     .with_sizing_behavior(gpui::ListSizingBehavior::Infer)
                     .with_decoration(ui::indent_guides(
@@ -64,10 +60,10 @@ impl Render for IndentGuidesStory {
                         px(16.),
                         ui::IndentGuideColors {
                             default: Color::Info.color(cx),
-                            hovered: Color::Accent.color(cx),
+                            hover: Color::Accent.color(cx),
                             active: Color::Accent.color(cx),
                         },
-                        |this, range, cx| {
+                        |this, range, _cx, _context| {
                             this.depths
                                 .iter()
                                 .skip(range.start)

crates/storybook/src/story_selector.rs

@@ -31,6 +31,7 @@ pub enum ComponentStory {
     ToggleButton,
     ViewportUnits,
     WithRemSize,
+    IndentGuides,
 }
 
 impl ComponentStory {
@@ -60,6 +61,7 @@ impl ComponentStory {
             Self::ToggleButton => cx.new(|_| ui::ToggleButtonStory).into(),
             Self::ViewportUnits => cx.new(|_| crate::stories::ViewportUnitsStory).into(),
             Self::WithRemSize => cx.new(|_| crate::stories::WithRemSizeStory).into(),
+            Self::IndentGuides => crate::stories::IndentGuidesStory::model(window, cx).into(),
         }
     }
 }

crates/storybook/src/storybook.rs

@@ -9,7 +9,9 @@ use std::sync::Arc;
 use clap::Parser;
 use dialoguer::FuzzySelect;
 use gpui::{
-    AnyView, App, Bounds, Context, Render, Window, WindowBounds, WindowOptions, div, px, size,
+    AnyView, App, Bounds, Context, Render, Window, WindowBounds, WindowOptions,
+    colors::{Colors, GlobalColors},
+    div, px, size,
 };
 use log::LevelFilter;
 use project::Project;
@@ -68,6 +70,8 @@ fn main() {
     gpui::Application::new().with_assets(Assets).run(move |cx| {
         load_embedded_fonts(cx).unwrap();
 
+        cx.set_global(GlobalColors(Arc::new(Colors::default())));
+
         let http_client = ReqwestClient::user_agent("zed_storybook").unwrap();
         cx.set_http_client(Arc::new(http_client));
 

crates/ui/src/traits/styled_ext.rs

@@ -39,7 +39,7 @@ pub trait StyledExt: Styled + Sized {
     /// Sets `bg()`, `rounded_lg()`, `border()`, `border_color()`, `shadow()`
     ///
     /// Example Elements: Title Bar, Panel, Tab Bar, Editor
-    fn elevation_1(self, cx: &mut App) -> Self {
+    fn elevation_1(self, cx: &App) -> Self {
         elevated(self, cx, ElevationIndex::Surface)
     }
 

crates/ui_input/src/ui_input.rs

@@ -29,7 +29,7 @@ pub struct SingleLineInput {
     label: Option<SharedString>,
     /// The placeholder text for the text field.
     placeholder: SharedString,
-    /// Exposes the underlying [`Model<Editor>`] to allow for customizing the editor beyond the provided API.
+    /// Exposes the underlying [`Entity<Editor>`] to allow for customizing the editor beyond the provided API.
     ///
     /// This likely will only be public in the short term, ideally the API will be expanded to cover necessary use cases.
     pub editor: Entity<Editor>,

crates/zed_actions/src/lib.rs

@@ -205,7 +205,12 @@ pub mod agent {
 
     actions!(
         agent,
-        [OpenConfiguration, OpenOnboardingModal, ResetOnboarding]
+        [
+            OpenConfiguration,
+            OpenOnboardingModal,
+            ResetOnboarding,
+            Chat
+        ]
     );
 }
 

docs/src/development/freebsd.md

@@ -16,15 +16,36 @@ Clone the [Zed repository](https://github.com/zed-industries/zed).
 
   If preferred, you can inspect [`script/freebsd`](https://github.com/zed-industries/zed/blob/main/script/freebsd) and perform the steps manually.
 
----
+## Building from source
 
-### ⚠️ WebRTC Notice
+Once the dependencies are installed, you can build Zed using [Cargo](https://doc.rust-lang.org/cargo/).
 
-Currently, building `webrtc-sys` on FreeBSD fails due to missing upstream support and unavailable prebuilt binaries.
-This is actively being worked on.
+For a debug build of the editor:
 
-More progress and discussion can be found in [Zed’s GitHub Discussions](https://github.com/zed-industries/zed/discussions/29550).
+```sh
+cargo run
+```
 
-_Environment:
-FreeBSD 14.2-RELEASE
-Architecture: amd64 (x86_64)_
+And to run the tests:
+
+```sh
+cargo test --workspace
+```
+
+In release mode, the primary user interface is the `cli` crate. You can run it in development with:
+
+```sh
+cargo run -p cli
+```
+
+### WebRTC Notice
+
+Currently, building `webrtc-sys` on FreeBSD fails due to missing upstream support and unavailable prebuilt binaries. As a result, some collaboration features (audio calls and screensharing) that depend on WebRTC are temporarily disabled.
+
+See [Issue #15309: FreeBSD Support] and [Discussion #29550: Unofficial FreeBSD port for Zed] for more.
+
+## Troubleshooting
+
+### Cargo errors claiming that a dependency is using unstable features
+
+Try `cargo clean` and `cargo build`.

docs/src/languages/ruby.md

@@ -340,3 +340,41 @@ Plain minitest does not support running tests by line number, only by name, so w
 ```
 
 Similar task syntax can be used for other test frameworks such as `quickdraw` or `tldr`.
+
+## Debugging
+
+The Ruby extension provides a debug adapter for debugging Ruby code. Zed's name for the adapter (in the UI and `debug.json`) is `rdbg`, and under the hood, it uses the [`debug`](https://github.com/ruby/debug) gem. The extension uses the [same activation logic](#language-server-activation) as the language servers.
+
+### Examples
+
+#### Debug a Ruby script
+
+```jsonc
+[
+  {
+    "label": "Debug current file",
+    "adapter": "rdbg",
+    "request": "launch",
+    "script": "$ZED_FILE",
+    "cwd": "$ZED_WORKTREE_ROOT",
+  },
+]
+```
+
+#### Debug Rails server
+
+```jsonc
+[
+  {
+    "label": "Debug Rails server",
+    "adapter": "rdbg",
+    "request": "launch",
+    "command": "$ZED_WORKTREE_ROOT/bin/rails",
+    "args": ["server"],
+    "cwd": "$ZED_WORKTREE_ROOT",
+    "env": {
+      "RUBY_DEBUG_OPEN": "true",
+    },
+  },
+]
+```