Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
Add create_thread and list_agents_and_models agent tools (#57987)
Eric Holk59f32d2135a9
diff --git a/assets/settings/default.json b/assets/settings/default.jsonindex bd32deca2ce..c65f18f0f2f 100644--- a/assets/settings/default.json+++ b/assets/settings/default.json@@ -1116,6 +1116,7 @@"tools": {"copy_path": true,"create_directory": true,+ "create_thread": true,"delete_path": true,"diagnostics": true,"apply_code_action": true,@@ -1126,6 +1127,7 @@"find_references": true,"get_code_actions": true,"go_to_definition": true,+ "list_agents_and_models": true,"list_directory": true,"move_path": true,"rename_symbol": true,@@ -1144,8 +1146,10 @@// We don't know which of the context server tools are safe for the "Ask" profile, so we don't enable them by default.// "enable_all_context_servers": true,"tools": {+ "create_thread": true,"diagnostics": true,"fetch": true,+ "list_agents_and_models": true,"list_directory": true,"find_path": true,"find_references": true,diff --git a/crates/agent/src/agent.rs b/crates/agent/src/agent.rsindex 35f7877c338..cbde8b524fc 100644--- a/crates/agent/src/agent.rs+++ b/crates/agent/src/agent.rs@@ -295,6 +295,25 @@ impl LanguageModels {}}+/// Implemented by the UI layer to provide the ability for agent tools to create+/// sibling threads that appear in the agent panel.+///+/// `agent_ui::AgentPanel` installs an implementation of this trait on the+/// `NativeAgent` when it sets up a connection. Tools in a native-agent thread+/// then discover and use the host via `NativeThreadEnvironment`. The UI side+/// is responsible for keeping the installed host current; a host whose+/// backing UI has been torn down will fail its first request with a clear+/// error rather than being detected up front.+pub trait SiblingThreadHost {+ fn create_sibling_thread(+ &self,+ request: SiblingThreadRequest,+ cx: &mut AsyncApp,+ ) -> Task<Result<SiblingThreadInfo>>;++ fn list_available_agents(&self, cx: &mut App) -> Result<AvailableAgents>;+}+pub struct NativeAgent {/// Session ID -> Session mappingsessions: HashMap<acp::SessionId, Session>,@@ -306,6 +325,8 @@ pub struct NativeAgent {templates: Arc<Templates>,/// Cached model informationmodels: LanguageModels,+ /// Handler installed by the UI for `create_thread` / `list_agents_and_models` tools.+ sibling_thread_host: Option<Rc<dyn SiblingThreadHost>>,fs: Arc<dyn Fs>,_subscriptions: Vec<Subscription>,/// Tracks the lifecycle of global skills directory observation. We@@ -469,6 +490,7 @@ impl NativeAgent {projects: HashMap::default(),templates,models: LanguageModels::new(cx),+ sibling_thread_host: None,fs,_subscriptions: subscriptions,skills_state: SkillsState::default(),@@ -595,6 +617,14 @@ impl NativeAgent {}}+ pub fn set_sibling_thread_host(&mut self, host: Rc<dyn SiblingThreadHost>) {+ self.sibling_thread_host = Some(host);+ }++ pub fn sibling_thread_host(&self) -> Option<Rc<dyn SiblingThreadHost>> {+ self.sibling_thread_host.clone()+ }+fn new_session(&mut self,project: Entity<Project>,@@ -2863,6 +2893,40 @@ impl ThreadEnvironment for NativeThreadEnvironment {) -> Result<Rc<dyn SubagentHandle>> {self.resume_subagent_thread(session_id, cx)}++ fn create_sibling_thread(+ &self,+ request: SiblingThreadRequest,+ cx: &mut AsyncApp,+ ) -> Task<Result<SiblingThreadInfo>> {+ let host = match self+ .agent+ .read_with(cx, |agent, _| agent.sibling_thread_host())+ {+ Ok(Some(host)) => host,+ Ok(None) => {+ return Task::ready(Err(anyhow!(+ "No sibling-thread host is registered. This usually means the \+ agent panel hasn't been initialized in this workspace."+ )));+ }+ Err(err) => return Task::ready(Err(err)),+ };+ host.create_sibling_thread(request, cx)+ }++ fn list_available_agents(&self, cx: &mut App) -> Result<AvailableAgents> {+ let host = self+ .agent+ .read_with(cx, |agent, _| agent.sibling_thread_host())?+ .ok_or_else(|| {+ anyhow!(+ "No sibling-thread host is registered. This usually means the \+ agent panel hasn't been initialized in this workspace."+ )+ })?;+ host.list_available_agents(cx)+ }}#[derive(Debug, Clone)]diff --git a/crates/agent/src/tests/mod.rs b/crates/agent/src/tests/mod.rsindex 47c4ee61f70..4cd1ebc8504 100644--- a/crates/agent/src/tests/mod.rs+++ b/crates/agent/src/tests/mod.rs@@ -5977,6 +5977,121 @@ async fn test_lsp_tools_gated_by_feature_flag(cx: &mut TestAppContext) {);}+#[gpui::test]+async fn test_sibling_thread_tools_gated_by_feature_flag(cx: &mut TestAppContext) {+ init_test(cx);++ // `CreateThreadToolFeatureFlag::enabled_for_staff()` returns true, which+ // means tests in debug builds resolve it to ON unless we explicitly+ // override it via `FeatureFlagsSettings`. Register the settings type and+ // install an (empty) `FeatureFlagStore` global so the `cx.has_flag` path+ // actually consults overrides instead of falling back to the+ // staff-debug-build default.+ cx.update(|cx| {+ SettingsStore::update_global(cx, |store, _| {+ store.register_setting::<feature_flags::FeatureFlagsSettings>();+ });+ cx.update_flags(false, vec![]);+ });++ fn set_flag_override(value: &str, cx: &mut TestAppContext) {+ cx.update(|cx| {+ SettingsStore::update_global(cx, |store, cx| {+ store.update_user_settings(cx, |content| {+ content+ .feature_flags+ .get_or_insert_default()+ .insert("create-thread-tool".to_string(), value.to_string());+ });+ });+ });+ }++ let fs = FakeFs::new(cx.executor());+ fs.insert_tree(path!("/test"), json!({})).await;+ let project = Project::test(fs, [path!("/test").as_ref()], cx).await;+ let project_context = cx.new(|_cx| ProjectContext::default());+ let context_server_store = project.read_with(cx, |project, _| project.context_server_store());+ let context_server_registry =+ cx.new(|cx| ContextServerRegistry::new(context_server_store.clone(), cx));+ let model = Arc::new(FakeLanguageModel::default());+ let environment = Rc::new(cx.update(|cx| {+ FakeThreadEnvironment::default().with_terminal(FakeTerminalHandle::new_never_exits(cx))+ }));++ let thread = cx.new(|cx| {+ let mut thread = Thread::new(+ project,+ project_context,+ context_server_registry,+ Templates::new(),+ Some(model.clone() as Arc<dyn LanguageModel>),+ cx,+ );+ thread.add_default_tools(environment, cx);+ thread+ });++ let sibling_tool_names = [CreateThreadTool::NAME, ListAgentsAndModelsTool::NAME];++ // Like the LSP/rename tools, sibling-thread tools are registered+ // unconditionally and gated only at exposure time. The registration must+ // be visible regardless of the flag's current value.+ thread.read_with(cx, |thread, _| {+ for name in &sibling_tool_names {+ assert!(+ thread.has_registered_tool(name),+ "expected sibling-thread tool {name} to be registered"+ );+ }+ });++ // Flag explicitly off: a completion request must omit the tools.+ set_flag_override("off", cx);+ thread+ .update(cx, |thread, cx| {+ thread.send(UserMessageId::new(), ["hello"], cx)+ })+ .unwrap();+ cx.run_until_parked();++ let completion = model.pending_completions().pop().unwrap();+ let tool_names = tool_names_for_completion(&completion);+ for name in &sibling_tool_names {+ assert!(+ !tool_names.iter().any(|t| t == name),+ "expected {name} to be hidden when create-thread-tool flag is off, \+ but completion tools were: {tool_names:?}"+ );+ }+ // Sanity check: an unrelated default tool should still be exposed.+ assert!(+ tool_names.iter().any(|t| t == ReadFileTool::NAME),+ "expected non-sibling-thread tools to still be exposed, got: {tool_names:?}"+ );+ model.end_last_completion_stream();+ cx.run_until_parked();++ // Flag explicitly on: the next completion request must include both tools.+ set_flag_override("on", cx);+ thread+ .update(cx, |thread, cx| {+ thread.send(UserMessageId::new(), ["hello again"], cx)+ })+ .unwrap();+ cx.run_until_parked();++ let completion = model.pending_completions().pop().unwrap();+ let tool_names = tool_names_for_completion(&completion);+ for name in &sibling_tool_names {+ assert!(+ tool_names.iter().any(|t| t == name),+ "expected {name} to be exposed when create-thread-tool flag is on, \+ but completion tools were: {tool_names:?}"+ );+ }+}+#[gpui::test]async fn test_parent_cancel_stops_subagent(cx: &mut TestAppContext) {init_test(cx);diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rsindex 96aeca7ff2e..d2111b56e4b 100644--- a/crates/agent/src/thread.rs+++ b/crates/agent/src/thread.rs@@ -1,17 +1,18 @@use crate::{ApplyCodeActionTool, CodeActionStore, ContextServerRegistry, CopyPathTool, CreateDirectoryTool,- DbLanguageModel, DbThread, DeletePathTool, DiagnosticsTool, EditFileTool, FetchTool,- FindPathTool, FindReferencesTool, GetCodeActionsTool, GoToDefinitionTool, GrepTool,- ListDirectoryTool, MovePathTool, ProjectSnapshot, ReadFileTool, RenameTool, SpawnAgentTool,- SystemPromptTemplate, Template, Templates, TerminalTool, ToolPermissionDecision,- UpdatePlanTool, UpdateTitleTool, WebSearchTool, WriteFileTool, decide_permission_from_settings,+ CreateThreadTool, DbLanguageModel, DbThread, DeletePathTool, DiagnosticsTool, EditFileTool,+ FetchTool, FindPathTool, FindReferencesTool, GetCodeActionsTool, GoToDefinitionTool, GrepTool,+ ListAgentsAndModelsTool, ListDirectoryTool, MovePathTool, ProjectSnapshot, ReadFileTool,+ RenameTool, SpawnAgentTool, SystemPromptTemplate, Template, Templates, TerminalTool,+ ToolPermissionDecision, UpdatePlanTool, UpdateTitleTool, WebSearchTool, WriteFileTool,+ decide_permission_from_settings,};use acp_thread::{MentionUri, UserMessageId};use action_log::ActionLog;use agent_settings::UserAgentsMd;use feature_flags::{- FeatureFlagAppExt as _, LspToolFeatureFlag, RenameToolFeatureFlag, UpdatePlanToolFeatureFlag,- UpdateTitleToolFeatureFlag,+ CreateThreadToolFeatureFlag, FeatureFlagAppExt as _, LspToolFeatureFlag, RenameToolFeatureFlag,+ UpdatePlanToolFeatureFlag, UpdateTitleToolFeatureFlag,};use agent_client_protocol::schema as acp;@@ -708,6 +709,97 @@ pub trait ThreadEnvironment {"Resuming subagent sessions is not supported"))}++ /// Creates an independent sibling thread visible in the agent sidebar.+ /// Unlike subagents, sibling threads are first-class threads that persist+ /// and run in parallel without reporting results back to the parent.+ fn create_sibling_thread(+ &self,+ request: SiblingThreadRequest,+ cx: &mut AsyncApp,+ ) -> Task<Result<SiblingThreadInfo>> {+ let _ = request;+ let _ = cx;+ Task::ready(Err(anyhow::anyhow!(+ "Creating sibling threads is not supported in this environment"+ )))+ }++ /// Lists the agents and models available for use with `create_sibling_thread`.+ fn list_available_agents(&self, cx: &mut App) -> Result<AvailableAgents> {+ let _ = cx;+ Err(anyhow::anyhow!(+ "Listing available agents is not supported in this environment"+ ))+ }+}++/// A request to create a new sibling thread.+#[derive(Debug, Clone)]+pub struct SiblingThreadRequest {+ /// A short title for the new thread, shown in the sidebar.+ pub title: SharedString,+ /// The initial prompt to send to the new thread.+ pub prompt: String,+ /// Optional agent ID to use. Defaults to the native Zed agent.+ pub agent_id: Option<String>,+ /// Optional model override, as `provider/model-id`.+ /// Defaults to the user's configured default model for the agent.+ pub model: Option<String>,+ /// Whether to create the thread in a new git worktree workspace.+ pub use_new_worktree: bool,+ /// Optional worktree directory name. When `None`, the UI generates a+ /// random non-colliding name (matching the manual "Create worktree"+ /// flow). Only relevant when `use_new_worktree` is true.+ pub worktree_name: Option<String>,+ /// Git ref (branch, tag, or commit) to base the new worktree on.+ /// Only relevant when `use_new_worktree` is true.+ pub base_ref: Option<String>,+}++/// Information returned when a sibling thread is successfully created.+#[derive(Debug, Clone)]+pub struct SiblingThreadInfo {+ /// The title assigned to the thread.+ pub title: SharedString,+ /// The agent ID used for the thread.+ pub agent_id: String,+ /// The model ID used for the thread, if known.+ pub model: Option<String>,+ /// An optional, non-fatal heads-up about the created thread that the+ /// caller should relay or take into account (e.g., the project had an+ /// unusual worktree layout that affected how the new worktree was set+ /// up). Empty when nothing noteworthy happened.+ pub warning: Option<String>,+}++/// A list of agents and, for each, the models available for use.+#[derive(Debug, Clone, Serialize, Deserialize)]+pub struct AvailableAgents {+ pub agents: Vec<AvailableAgent>,+}++#[derive(Debug, Clone, Serialize, Deserialize)]+pub struct AvailableAgent {+ /// Identifier used when creating a thread.+ pub id: String,+ /// Human-readable name shown in the UI.+ pub name: SharedString,+ /// Whether this is Zed's built-in native agent.+ pub is_native: bool,+ /// Models available for this agent. May be empty if models are not+ /// enumerated up front (e.g., external agents that choose their own).+ pub models: Vec<AvailableModel>,+}++#[derive(Debug, Clone, Serialize, Deserialize)]+pub struct AvailableModel {+ /// Identifier to pass as the `model` field when creating a thread.+ pub id: String,+ /// Human-readable name.+ pub name: SharedString,+ /// Whether this is the default model for the agent.+ pub is_default: bool,}#[derive(Debug)]@@ -1770,8 +1862,16 @@ impl Thread {self.add_tool(RenameTool::new(self.project.clone()));if self.depth() < MAX_SUBAGENT_DEPTH {- self.add_tool(SpawnAgentTool::new(environment));+ self.add_tool(SpawnAgentTool::new(environment.clone()));}++ // Sibling-thread tools are exposed at every depth: a subagent should+ // still be able to kick off independent sibling work on behalf of the+ // user, even when it can no longer nest further subagents. Visibility+ // to the model is gated by `CreateThreadToolFeatureFlag` in+ // `Thread::enabled_tools`.+ self.add_tool(CreateThreadTool::new(environment.clone()));+ self.add_tool(ListAgentsAndModelsTool::new(environment));}pub fn add_tool<T: AgentTool>(&mut self, tool: T) {@@ -3096,6 +3196,9 @@ impl Thread {| GetCodeActionsTool::NAME| ApplyCodeActionTool::NAME| GoToDefinitionTool::NAME => cx.has_flag::<LspToolFeatureFlag>(),+ CreateThreadTool::NAME | ListAgentsAndModelsTool::NAME => {+ cx.has_flag::<CreateThreadToolFeatureFlag>()+ }_ => true,}).collect::<BTreeMap<_, _>>();diff --git a/crates/agent/src/tools.rs b/crates/agent/src/tools.rsindex 187ce7f6578..282d5531493 100644--- a/crates/agent/src/tools.rs+++ b/crates/agent/src/tools.rs@@ -2,6 +2,7 @@ mod apply_code_action_tool;mod context_server_registry;mod copy_path_tool;mod create_directory_tool;+mod create_thread_tool;mod delete_path_tool;mod diagnostics_tool;mod edit_file_tool;@@ -14,6 +15,7 @@ mod find_references_tool;mod get_code_actions_tool;mod go_to_definition_tool;mod grep_tool;+mod list_agents_and_models_tool;mod list_directory_tool;mod move_path_tool;mod read_file_tool;@@ -62,6 +64,7 @@ pub use apply_code_action_tool::*;pub use context_server_registry::*;pub use copy_path_tool::*;pub use create_directory_tool::*;+pub use create_thread_tool::*;pub use delete_path_tool::*;pub use diagnostics_tool::*;pub use edit_file_tool::*;@@ -71,6 +74,7 @@ pub use find_references_tool::*;pub use get_code_actions_tool::*;pub use go_to_definition_tool::*;pub use grep_tool::*;+pub use list_agents_and_models_tool::*;pub use list_directory_tool::*;pub use move_path_tool::*;pub use read_file_tool::*;@@ -153,10 +157,23 @@ macro_rules! tools {};}+// Adding a tool here (and constructing it in `Thread::add_default_tools`) is+// not enough to make the model actually receive it. Two further gates will+// silently drop the tool rather than fail to compile:+//+// 1. `assets/settings/default.json`: the `write` and `ask` agent profiles each+// carry an explicit `tools` allowlist. `Thread::enabled_tools` filters out+// any tool not present there with value `true`, so it never reaches the+// model.+// 2. `test_all_tools_are_in_tool_info_or_excluded` in+// `crates/settings_ui/src/pages/tool_permissions_setup.rs`: every tool must+// be in the permission-UI `TOOLS` list (if it calls+// `decide_permission_from_settings`) or in `EXCLUDED_TOOLS`.tools! {ApplyCodeActionTool,CopyPathTool,CreateDirectoryTool,+ CreateThreadTool,DeletePathTool,DiagnosticsTool,EditFileTool,@@ -166,6 +183,7 @@ tools! {GetCodeActionsTool,GoToDefinitionTool,GrepTool,+ ListAgentsAndModelsTool,ListDirectoryTool,MovePathTool,ReadFileTool,diff --git a/crates/agent/src/tools/create_thread_tool.rs b/crates/agent/src/tools/create_thread_tool.rsnew file mode 100644index 00000000000..9f87412d027--- /dev/null+++ b/crates/agent/src/tools/create_thread_tool.rs@@ -0,0 +1,201 @@+use agent_client_protocol::schema as acp;+use anyhow::Result;+use gpui::{App, SharedString, Task};+use language_model::LanguageModelToolResultContent;+use schemars::JsonSchema;+use serde::{Deserialize, Serialize};+use std::rc::Rc;+use std::sync::Arc;++use crate::{AgentTool, SiblingThreadRequest, ThreadEnvironment, ToolCallEventStream, ToolInput};++/// Create a new agent thread that runs in parallel with this one.+///+/// Use this to kick off separable pieces of work without interrupting the current+/// conversation. The new thread appears in the agent sidebar just like a thread+/// the user created themselves, and runs independently — you will NOT receive+/// its output and you cannot interact with it afterwards. Use `spawn_agent`+/// instead if you need the results back.+///+/// A successful call returns only the title, agent ID, and model used; there is+/// currently no way to look up or control a sibling thread by session ID.+///+/// ### When to use+/// - The user asks you to start another thread, investigation, or exploration on the side.+/// - You notice a separable task (refactor, bug fix, investigation) that shouldn't+/// derail the current conversation but is worth pursuing.+///+/// ### Prompt design+/// The new thread has no access to this conversation's history. Include in `prompt`+/// everything the new agent needs: goals, relevant file paths, constraints, and+/// context. Assume the new thread starts from a blank slate in the same project.+///+/// ### Agent and model selection+/// - If you don't know what agents or models are available, call `list_agents_and_models`.+/// - For bulk / lightweight work (e.g., spawning many parallel threads), prefer a+/// cheaper / faster model over the default.+/// - Leave `agent` and `model` unset to use the user's current defaults.+///+/// ### Worktree support+/// Set `use_new_worktree` to true to spawn the sibling inside a brand-new+/// workspace (a new tab) backed by linked git worktrees of each git+/// repository in the current project. This mirrors what the user gets when+/// they manually pick "Create worktree" from the worktree picker.+///+/// - The new workspace opens in its own tab; switch to it manually to see+/// the sibling's progress.+/// - The new worktrees start in detached HEAD state. Use `base_ref` to base+/// them off a specific branch, tag, or commit; omit it to base off `HEAD`.+/// The agent in the sibling thread can attach to a branch by running+/// `git switch -c <branch>` in its terminal if needed.+/// - `worktree_name` overrides the autogenerated directory name. Omit it to+/// let the editor pick a random non-colliding name.+/// - The project must contain at least one git repository, otherwise the+/// call fails.+///+/// Use this when the sibling needs to make changes that shouldn't touch the+/// user's current working tree (e.g., risky refactors, parallel experiments,+/// or work the user wants to review independently).+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]+#[serde(rename_all = "snake_case")]+pub struct CreateThreadToolInput {+ /// Short descriptive title for the new thread, shown in the sidebar+ /// (e.g., "Investigate flaky login test").+ pub title: String,++ /// The initial prompt to send to the new thread. Include all the context the+ /// new agent needs — files, goals, constraints — because it has no access to+ /// the current conversation's history.+ pub prompt: String,++ /// Optional agent ID to use. Omit to use the user's currently selected agent.+ /// Call `list_agents_and_models` if you need to see what's available.+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub agent: Option<String>,++ /// Optional model override as `provider/model-id` (e.g.,+ /// `anthropic/claude-haiku-4-latest`). Only meaningful for Zed's native+ /// agent. Omit to use the user's configured default.+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub model: Option<String>,++ /// If true, create the thread in a new git worktree rather than sharing+ /// the parent's worktree. The project must contain a git repository.+ #[serde(default)]+ pub use_new_worktree: bool,++ /// Optional name for the new worktree directory. When omitted, the+ /// editor generates a random non-colliding name (matching the+ /// manual "Create worktree" UI behavior). Only used when+ /// `use_new_worktree` is true.+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub worktree_name: Option<String>,++ /// Git ref (branch, tag, or commit) to base the new worktree on. Only+ /// used when `use_new_worktree` is true. Defaults to `HEAD`.+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub base_ref: Option<String>,+}++#[derive(Debug, Clone, Serialize, Deserialize)]+#[serde(untagged)]+pub enum CreateThreadToolOutput {+ Success {+ title: String,+ agent_id: String,+ #[serde(skip_serializing_if = "Option::is_none")]+ model: Option<String>,+ /// A non-fatal heads-up about the created thread (e.g., the project's+ /// worktree layout was unusual and the new worktree may not match+ /// expectations). Present only when there's something to flag.+ #[serde(skip_serializing_if = "Option::is_none")]+ warning: Option<String>,+ },+ Error {+ error: String,+ },+}++impl From<CreateThreadToolOutput> for LanguageModelToolResultContent {+ fn from(output: CreateThreadToolOutput) -> Self {+ serde_json::to_string(&output)+ .unwrap_or_else(|e| format!("Failed to serialize create_thread output: {e}"))+ .into()+ }+}++pub struct CreateThreadTool {+ environment: Rc<dyn ThreadEnvironment>,+}++impl CreateThreadTool {+ pub fn new(environment: Rc<dyn ThreadEnvironment>) -> Self {+ Self { environment }+ }+}++impl AgentTool for CreateThreadTool {+ type Input = CreateThreadToolInput;+ type Output = CreateThreadToolOutput;++ const NAME: &'static str = "create_thread";++ fn kind() -> acp::ToolKind {+ acp::ToolKind::Other+ }++ fn initial_title(+ &self,+ input: Result<Self::Input, serde_json::Value>,+ _cx: &mut App,+ ) -> SharedString {+ match input {+ Ok(i) => format!("Create thread: {}", i.title).into(),+ Err(value) => value+ .get("title")+ .and_then(|v| v.as_str())+ .map(|s| format!("Create thread: {s}").into())+ .unwrap_or_else(|| "Create thread".into()),+ }+ }++ fn run(+ self: Arc<Self>,+ input: ToolInput<Self::Input>,+ _event_stream: ToolCallEventStream,+ cx: &mut App,+ ) -> Task<Result<Self::Output, Self::Output>> {+ cx.spawn(async move |cx| {+ let input = input+ .recv()+ .await+ .map_err(|e| CreateThreadToolOutput::Error {+ error: format!("Failed to receive tool input: {e}"),+ })?;++ let title: SharedString = input.title.clone().into();+ let request = SiblingThreadRequest {+ title: title.clone(),+ prompt: input.prompt,+ agent_id: input.agent,+ model: input.model,+ use_new_worktree: input.use_new_worktree,+ worktree_name: input.worktree_name,+ base_ref: input.base_ref,+ };++ let task = self.environment.create_sibling_thread(request, cx);+ match task.await {+ Ok(info) => Ok(CreateThreadToolOutput::Success {+ title: info.title.to_string(),+ agent_id: info.agent_id,+ model: info.model,+ warning: info.warning,+ }),+ Err(error) => Err(CreateThreadToolOutput::Error {+ error: error.to_string(),+ }),+ }+ })+ }+}diff --git a/crates/agent/src/tools/list_agents_and_models_tool.rs b/crates/agent/src/tools/list_agents_and_models_tool.rsnew file mode 100644index 00000000000..5c9b2b22df4--- /dev/null+++ b/crates/agent/src/tools/list_agents_and_models_tool.rs@@ -0,0 +1,78 @@+use agent_client_protocol::schema as acp;+use anyhow::Result;+use gpui::{App, SharedString, Task};+use language_model::LanguageModelToolResultContent;+use schemars::JsonSchema;+use serde::{Deserialize, Serialize};+use std::rc::Rc;+use std::sync::Arc;++use crate::{AgentTool, AvailableAgents, ThreadEnvironment, ToolCallEventStream, ToolInput};++/// List the agents and models available for use with the `create_thread` tool.+///+/// Call this before `create_thread` if you need to pick a specific agent or a+/// non-default model (for example, to use a cheaper model for bulk work). If+/// you're happy with the user's current defaults, you don't need to call this.+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]+#[serde(rename_all = "snake_case")]+pub struct ListAgentsAndModelsToolInput {}++#[derive(Debug, Clone, Serialize, Deserialize)]+#[serde(untagged)]+pub enum ListAgentsAndModelsToolOutput {+ Success(AvailableAgents),+ Error { error: String },+}++impl From<ListAgentsAndModelsToolOutput> for LanguageModelToolResultContent {+ fn from(output: ListAgentsAndModelsToolOutput) -> Self {+ serde_json::to_string(&output)+ .unwrap_or_else(|e| format!("Failed to serialize list_agents_and_models output: {e}"))+ .into()+ }+}++pub struct ListAgentsAndModelsTool {+ environment: Rc<dyn ThreadEnvironment>,+}++impl ListAgentsAndModelsTool {+ pub fn new(environment: Rc<dyn ThreadEnvironment>) -> Self {+ Self { environment }+ }+}++impl AgentTool for ListAgentsAndModelsTool {+ type Input = ListAgentsAndModelsToolInput;+ type Output = ListAgentsAndModelsToolOutput;++ const NAME: &'static str = "list_agents_and_models";++ fn kind() -> acp::ToolKind {+ acp::ToolKind::Other+ }++ fn initial_title(+ &self,+ _input: Result<Self::Input, serde_json::Value>,+ _cx: &mut App,+ ) -> SharedString {+ "List agents and models".into()+ }++ fn run(+ self: Arc<Self>,+ _input: ToolInput<Self::Input>,+ _event_stream: ToolCallEventStream,+ cx: &mut App,+ ) -> Task<Result<Self::Output, Self::Output>> {+ let result = self.environment.list_available_agents(cx);+ Task::ready(match result {+ Ok(agents) => Ok(ListAgentsAndModelsToolOutput::Success(agents)),+ Err(error) => Err(ListAgentsAndModelsToolOutput::Error {+ error: error.to_string(),+ }),+ })+ }+}diff --git a/crates/agent_ui/Cargo.toml b/crates/agent_ui/Cargo.tomlindex acabc22a95c..62ff6ac2140 100644--- a/crates/agent_ui/Cargo.toml+++ b/crates/agent_ui/Cargo.toml@@ -57,6 +57,7 @@ file_icons.workspace = truefs.workspace = truefutures.workspace = truegit.workspace = true+git_ui.workspace = truefuzzy.workspace = truegpui.workspace = truegpui_tokio.workspace = true@@ -125,7 +126,6 @@ clock = { workspace = true, features = ["test-support"] }db = { workspace = true, features = ["test-support"] }editor = { workspace = true, features = ["test-support"] }eval_utils.workspace = true-git_ui.workspace = truegpui = { workspace = true, "features" = ["test-support"] }http_client = { workspace = true, features = ["test-support"] }indoc.workspace = truediff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rsindex fed230c48ce..d96946d4942 100644--- a/crates/agent_ui/src/agent_panel.rs+++ b/crates/agent_ui/src/agent_panel.rs@@ -1,4 +1,5 @@use std::{+ cell::Cell,fmt,path::PathBuf,rc::Rc,@@ -49,7 +50,9 @@ use crate::{OpenAgentDiff, ResetFastModeWarnings, ResetTrialEndUpsell, ResetTrialUpsell,ShowAllSidebarThreadMetadata, ShowThreadMetadata, ToggleNewThreadMenu, ToggleOptionsMenu,agent_configuration::{AgentConfiguration, AssistantConfigurationEvent},- conversation_view::{AcpThreadViewEvent, ThreadView, reset_fast_mode_warnings},+ conversation_view::{+ AcpThreadViewEvent, RootThreadUpdated, ThreadView, reset_fast_mode_warnings,+ },ui::{AgentNotification, AgentNotificationEvent, EndTrialUpsell},};use crate::{@@ -58,7 +61,7 @@ use crate::{};use agent_settings::AgentSettings;use ai_onboarding::AgentPanelOnboarding;-use anyhow::Result;+use anyhow::{Context as _, Result, anyhow};#[cfg(feature = "audio")]use audio::{Audio, Sound};use chrono::{DateTime, Utc};@@ -67,6 +70,7 @@ use cloud_api_types::Plan;use collections::HashMap;use editor::{Editor, MultiBuffer};use extension_host::ExtensionStore;+use feature_flags::{CreateThreadToolFeatureFlag, FeatureFlagAppExt as _};use fs::Fs;use gpui::{@@ -862,6 +866,26 @@ fn thread_metadata_to_debug_json(})}+/// Optional parameters for `AgentPanel::create_thread_with_options`. All+/// fields default to the panel's current selection so the agent tool only+/// needs to override what it actually cares about.+#[derive(Default)]+pub struct CreateThreadOptions {+ /// Title to assign to the new thread up front.+ pub title: Option<SharedString>,+ /// Initial content to populate in the thread (optionally auto-submitted).+ pub initial_content: Option<AgentInitialContent>,+ /// Agent to use. Defaults to the panel's selected agent.+ pub agent: Option<Agent>,+ /// Model override, as `provider/model-id`. Only applied when the thread+ /// uses the native Zed agent.+ pub model: Option<String>,+ /// Working directories to attach to the new thread (e.g., the path of a+ /// freshly-created sibling worktree). When `None`, the thread inherits+ /// the project's default path list.+ pub work_dirs: Option<PathList>,+}+pub(crate) struct AgentThread {conversation_view: Entity<ConversationView>,}@@ -1794,6 +1818,7 @@ impl AgentPanel {Some(metadata.folder_paths().clone()),metadata.title.clone(),initial_content,+ None,AgentThreadSource::AgentPanel,window,cx,@@ -2797,6 +2822,7 @@ impl AgentPanel {None,None,None,+ None,source,window,cx,@@ -2964,6 +2990,61 @@ impl AgentPanel {self.serialize(cx);}+ /// Creates a new retained thread and inserts it into the sidebar without+ /// switching the active view to it. Used by the `create_thread` agent tool,+ /// which passes an initial prompt, and optionally an agent and model+ /// override.+ pub fn create_thread_with_options(+ &mut self,+ options: CreateThreadOptions,+ source: AgentThreadSource,+ window: &mut Window,+ cx: &mut Context<Self>,+ ) -> ThreadId {+ let (agent, override_used) = if self.project.read(cx).is_via_collab() {+ (Agent::NativeAgent, false)+ } else if let Some(override_agent) = options.agent {+ (override_agent, true)+ } else {+ (self.selected_agent.clone(), false)+ };+ // If the caller explicitly overrode the agent (e.g., the `create_thread`+ // tool wants to spawn a sibling thread using a specific agent), we+ // shouldn't let that change the panel's selected_agent or the+ // last-used-agent preference. Snapshot and restore both.+ let saved_selected_agent = override_used.then(|| self.selected_agent.clone());+ let thread = self.create_agent_thread_with_server(+ agent,+ None,+ None,+ options.work_dirs,+ options.title.clone(),+ options.initial_content,+ options.model,+ source,+ window,+ cx,+ );+ if let Some(original) = saved_selected_agent {+ if self.selected_agent != original {+ self.selected_agent = original.clone();+ self.serialize(cx);+ // Restore the last-used-agent in persistent storage as well.+ cx.background_spawn({+ let kvp = KeyValueStore::global(cx);+ async move {+ write_global_last_used_agent(kvp, original).await;+ }+ })+ .detach();+ }+ }+ let thread_id = thread.conversation_view.read(cx).thread_id;+ self.retained_threads+ .insert(thread_id, thread.conversation_view);+ thread_id+ }+pub fn activate_retained_thread(&mut self,id: ThreadId,@@ -3217,6 +3298,7 @@ impl AgentPanel {work_dirs,title,initial_content,+ None,source,window,cx,@@ -4268,6 +4350,7 @@ impl AgentPanel {work_dirs: Option<PathList>,title: Option<SharedString>,initial_content: Option<AgentInitialContent>,+ model_override: Option<String>,source: AgentThreadSource,window: &mut Window,cx: &mut Context<Self>,@@ -4284,6 +4367,7 @@ impl AgentPanel {work_dirs,title,initial_content,+ model_override,source,window,cx,@@ -4318,6 +4402,7 @@ impl AgentPanel {work_dirs,title,initial_content,+ None,source,window,cx,@@ -4333,6 +4418,7 @@ impl AgentPanel {work_dirs: Option<PathList>,title: Option<SharedString>,initial_content: Option<AgentInitialContent>,+ model_override: Option<String>,source: AgentThreadSource,window: &mut Window,cx: &mut Context<Self>,@@ -4384,23 +4470,74 @@ impl AgentPanel {)});- cx.observe(&conversation_view, |this, server_view, cx| {- let is_active = this- .active_conversation_view()- .is_some_and(|active| active.entity_id() == server_view.entity_id());- if is_active {- cx.emit(AgentPanelEvent::ActiveViewChanged);- this.serialize(cx);- } else {- cx.emit(AgentPanelEvent::EntryChanged);- }- cx.notify();- })+ cx.observe_in(+ &conversation_view,+ window,+ |this, server_view, window, cx| {+ let is_active = this+ .active_conversation_view()+ .is_some_and(|active| active.entity_id() == server_view.entity_id());+ if is_active {+ cx.emit(AgentPanelEvent::ActiveViewChanged);+ this.serialize(cx);+ } else {+ cx.emit(AgentPanelEvent::EntryChanged);+ }+ this.ensure_sibling_host_installed(&server_view, window, cx);+ cx.notify();+ },+ ).detach();+ // Try installing the host eagerly as well, in case the connection is+ // already established by the time the observe fires.+ self.ensure_sibling_host_installed(&conversation_view, window, cx);++ if let Some(model) = model_override {+ // The native thread is constructed asynchronously after the+ // connection establishes. Wait for the first `RootThreadUpdated`+ // event that yields a native thread, then apply the override once.+ let applied = Cell::new(false);+ cx.subscribe(+ &conversation_view,+ move |_this, view, _event: &RootThreadUpdated, cx| {+ if applied.get() {+ return;+ }+ let Some(native_thread) = view.read(cx).as_native_thread(cx) else {+ return;+ };+ apply_native_model_override(&native_thread, &model, cx);+ applied.set(true);+ },+ )+ .detach();+ }+AgentThread { conversation_view }}+ fn ensure_sibling_host_installed(+ &self,+ conversation_view: &Entity<ConversationView>,+ window: &mut Window,+ cx: &mut Context<Self>,+ ) {+ if !cx.has_flag::<CreateThreadToolFeatureFlag>() {+ return;+ }+ let Some(native_connection) = conversation_view.read(cx).as_native_connection(cx) else {+ return;+ };+ let host = Rc::new(AgentPanelSiblingHost::new(+ cx.weak_entity(),+ window.window_handle(),+ )) as Rc<dyn agent::SiblingThreadHost>;+ native_connection.0.update(cx, |native_agent, _cx| {+ native_agent.set_sibling_thread_host(host);+ });+ }+fn active_thread_has_messages(&self, cx: &App) -> bool {self.active_agent_thread(cx).is_some_and(|thread| !thread.read(cx).entries().is_empty())@@ -4425,6 +4562,272 @@ impl AgentPanel {}}+/// Apply a `provider/model-id` model override to a freshly-created native thread.+/// Best-effort: logs an error and leaves the default model in place if the+/// string can't be parsed or the model isn't registered.+pub(crate) fn apply_native_model_override(+ thread: &Entity<agent::Thread>,+ model_id: &str,+ cx: &mut App,+) {+ let Some(selected) = parse_provider_slash_model(model_id) else {+ log::warn!(+ "create_thread: could not parse model override {model_id:?}; expected `provider/model-id`"+ );+ return;+ };+ let configured = LanguageModelRegistry::global(cx)+ .update(cx, |registry, cx| registry.select_model(&selected, cx));+ let Some(configured) = configured else {+ log::warn!(+ "create_thread: no model registered for {model_id:?}; using thread's default model"+ );+ return;+ };+ thread.update(cx, |thread, cx| {+ thread.set_model(configured.model, cx);+ });+}++fn parse_provider_slash_model(input: &str) -> Option<language_model::SelectedModel> {+ let (provider, model) = input.split_once('/')?;+ if provider.is_empty() || model.is_empty() {+ return None;+ }+ Some(language_model::SelectedModel {+ provider: language_model::LanguageModelProviderId::from(provider.to_string()),+ model: language_model::LanguageModelId::from(model.to_string()),+ })+}++/// Bridges agent-side `SiblingThreadHost` calls to `AgentPanel`. Constructed+/// and installed on a `NativeAgent` by the agent panel when a native-agent+/// thread is created.+pub(crate) struct AgentPanelSiblingHost {+ panel: WeakEntity<AgentPanel>,+ window: gpui::AnyWindowHandle,+}++impl AgentPanelSiblingHost {+ pub(crate) fn new(panel: WeakEntity<AgentPanel>, window: gpui::AnyWindowHandle) -> Self {+ Self { panel, window }+ }+}++impl agent::SiblingThreadHost for AgentPanelSiblingHost {+ fn create_sibling_thread(+ &self,+ request: agent::SiblingThreadRequest,+ cx: &mut gpui::AsyncApp,+ ) -> Task<Result<agent::SiblingThreadInfo>> {+ let panel = self.panel.clone();+ let window = self.window;+ cx.spawn(async move |cx| {+ let agent_choice = match request.agent_id.as_deref() {+ None => None,+ Some(id) if id == agent::ZED_AGENT_ID.as_ref() => Some(Agent::NativeAgent),+ Some(id) => {+ // Reject unknown agent ids up front so the model gets a+ // structured error pointing at `list_agents_and_models`,+ // rather than a thread that silently fails to launch in+ // the user's sidebar.+ let known = panel+ .read_with(cx, |panel, cx| {+ let store = panel.project.read(cx).agent_server_store().clone();+ store+ .read(cx)+ .external_agents()+ .any(|known_id| known_id.0.as_ref() == id)+ })+ .unwrap_or(false);+ if !known {+ return Err(anyhow!(+ "Unknown agent id {id:?}. Call `list_agents_and_models` \+ to see the agents available for `create_thread`."+ ));+ }+ Some(Agent::Custom {+ id: project::AgentId(id.to_string().into()),+ })+ }+ };++ let initial_content = AgentInitialContent::ContentBlock {+ blocks: vec![acp::ContentBlock::Text(acp::TextContent::new(+ request.prompt.clone(),+ ))],+ auto_submit: true,+ };++ let title: SharedString = request.title.clone();+ let options = CreateThreadOptions {+ title: Some(title.clone()),+ initial_content: Some(initial_content),+ agent: agent_choice.clone(),+ model: request.model.clone(),+ work_dirs: None,+ };++ // If the caller asked for a fresh worktree, open a new workspace+ // backed by a linked git worktree of each git repo in the parent+ // project — the same flow the user gets when they pick "Create+ // worktree" from the worktree picker. The sibling thread is then+ // created inside the new workspace's agent panel, so it lives+ // alongside any threads the user would create there manually.+ let mut worktree_warning: Option<String> = None;+ let target_panel = if request.use_new_worktree {+ let workspace = panel.read_with(cx, |panel, _cx| panel.workspace.clone())?;+ let workspace = workspace+ .upgrade()+ .ok_or_else(|| anyhow!("Source workspace is no longer available"))?;+ // The branch target follows the existing UI semantics: when+ // `base_ref` is set, treat it as the ref to base off of+ // (resolved like `git switch --detach <ref>`); otherwise base+ // off the current HEAD. Either way the new worktrees are in+ // detached HEAD state — the agent can attach to a branch via+ // git afterwards.+ let branch_target = match request.base_ref.as_ref() {+ Some(ref_name) => zed_actions::NewWorktreeBranchTarget::ExistingBranch {+ name: ref_name.clone(),+ },+ None => zed_actions::NewWorktreeBranchTarget::CurrentBranch,+ };+ let action = zed_actions::CreateWorktree {+ worktree_name: request.worktree_name.clone(),+ branch_target,+ };+ let creation = window.update(cx, |_root, window, cx| {+ workspace.update(cx, |workspace, cx| {+ git_ui::worktree_service::create_worktree_workspace(+ workspace, &action, window, None, cx,+ )+ })+ })?;+ let created = creation+ .await+ .context("failed to create worktree workspace")?;+ // The creation flow tells us when the project had multiple+ // worktrees of the same underlying repo, which it consolidates+ // into one new worktree — flag it so the calling agent knows+ // the result may not reflect every source worktree's state.+ if created.consolidated_worktrees {+ worktree_warning = Some(+ "The project contained multiple worktrees backed by the same git \+ repository, so they were consolidated into a single new worktree. \+ The new thread's worktree is based on one of them and may not \+ reflect the exact state of the others."+ .to_string(),+ );+ }+ // Locate the agent panel on the new workspace. We rely on+ // the panel having registered by the time+ // `create_worktree_workspace` returns — `open_worktree_workspace`+ // explicitly awaits `take_panels_task` and the initial scan.+ created+ .workspace+ .read_with(cx, |workspace, cx| workspace.panel::<AgentPanel>(cx))+ .ok_or_else(|| anyhow!("new workspace did not register an agent panel"))?+ .downgrade()+ } else {+ panel.clone()+ };+ // Both the source panel and any newly-opened worktree workspace+ // live in the same OS window (the new workspace is a tab on the+ // existing MultiWorkspace), so the original window handle is+ // still the right context for the `create_thread_with_options`+ // call regardless of which panel ends up the target.+ let target_window = window;++ // We deliberately don't wait for the new thread's session to+ // become available here: there are currently no agent tools that+ // operate on sibling threads by session ID, so requiring one would+ // just introduce a race for no benefit.+ let resolved_agent_id = target_window.update(cx, |_root, window, cx| {+ target_panel.update(cx, |panel, cx| {+ panel.create_thread_with_options(+ options,+ AgentThreadSource::AgentPanel,+ window,+ cx,+ );+ let resolved_agent = agent_choice+ .clone()+ .unwrap_or_else(|| panel.selected_agent.clone());+ resolved_agent.id()+ })+ })??;++ Ok(agent::SiblingThreadInfo {+ title,+ agent_id: resolved_agent_id.0.to_string(),+ model: request.model,+ warning: worktree_warning,+ })+ })+ }++ fn list_available_agents(&self, cx: &mut App) -> Result<agent::AvailableAgents> {+ let panel = self+ .panel+ .upgrade()+ .ok_or_else(|| anyhow!("Agent panel is no longer available"))?;++ let mut agents = Vec::new();++ // Native Zed agent — always available, and we can enumerate models+ // directly from the language model registry.+ let native_models = {+ let registry = LanguageModelRegistry::read_global(cx);+ let default = registry.default_model();+ let mut models = Vec::new();+ for provider in registry.providers() {+ if !provider.is_authenticated(cx) {+ continue;+ }+ let provider_id = provider.id();+ for model in provider.provided_models(cx) {+ let id = format!("{}/{}", provider_id.0, model.id().0);+ let is_default = default+ .as_ref()+ .map(|cm| cm.provider.id() == provider_id && cm.model.id() == model.id())+ .unwrap_or(false);+ models.push(agent::AvailableModel {+ id,+ name: model.name().0,+ is_default,+ });+ }+ }+ models+ };+ agents.push(agent::AvailableAgent {+ id: agent::ZED_AGENT_ID.to_string(),+ name: Agent::NativeAgent.label(),+ is_native: true,+ models: native_models,+ });++ let project = panel.read(cx).project.clone();+ let agent_server_store = project.read(cx).agent_server_store().clone();+ let store = agent_server_store.read(cx);+ for agent_id in store.external_agents() {+ let display = store+ .agent_display_name(agent_id)+ .unwrap_or_else(|| agent_id.0.clone());+ agents.push(agent::AvailableAgent {+ id: agent_id.0.to_string(),+ name: display,+ is_native: false,+ // External agents pick their own models dynamically; we don't+ // try to enumerate them ahead of time.+ models: Vec::new(),+ });+ }++ Ok(agent::AvailableAgents { agents })+ }+}+impl Focusable for AgentPanel {fn focus_handle(&self, cx: &App) -> FocusHandle {match self.visible_surface() {@@ -4778,6 +5181,7 @@ impl AgentPanel {None,None,Some(initial_content),+ None,AgentThreadSource::AgentPanel,window,cx,@@ -6100,6 +6504,7 @@ impl AgentPanel {None,None,None,+ None,AgentThreadSource::AgentPanel,window,cx,@@ -6139,6 +6544,7 @@ impl AgentPanel {None,None,None,+ None,AgentThreadSource::AgentPanel,window,cx,@@ -6172,6 +6578,7 @@ impl AgentPanel {None,None,None,+ None,AgentThreadSource::AgentPanel,window,cx,@@ -12373,4 +12780,77 @@ mod tests {);});}++ #[gpui::test]+ async fn test_create_thread_with_options_retains_thread_and_restores_agent(+ cx: &mut TestAppContext,+ ) {+ let (panel, mut cx) = setup_panel(cx).await;+ let _stub_connection =+ crate::test_support::set_stub_agent_connection(StubAgentConnection::new());++ // Baseline: panel's selected_agent is the stub.+ panel.update(&mut cx, |panel, _cx| {+ panel.selected_agent = Agent::Stub;+ });++ // Case 1: no agent override. The new thread should land in+ // `retained_threads` and `selected_agent` should be unchanged.+ let no_override_id = panel.update_in(&mut cx, |panel, window, cx| {+ panel.create_thread_with_options(+ CreateThreadOptions::default(),+ AgentThreadSource::AgentPanel,+ window,+ cx,+ )+ });++ panel.read_with(&cx, |panel, _cx| {+ assert!(+ panel.retained_threads.contains_key(&no_override_id),+ "thread created via create_thread_with_options should be retained"+ );+ assert_eq!(+ panel.selected_agent,+ Agent::Stub,+ "selected_agent should be unchanged when no agent override is requested"+ );+ });++ // Case 2: an explicit agent override that differs from the panel's+ // selection. `create_agent_thread_inner` updates `selected_agent` as a+ // side effect; `create_thread_with_options` must restore it so the+ // user's last-used agent isn't silently flipped by an agent-initiated+ // call.+ let override_agent = Agent::Custom {+ id: "override-agent".into(),+ };+ let override_id = panel.update_in(&mut cx, |panel, window, cx| {+ panel.create_thread_with_options(+ CreateThreadOptions {+ agent: Some(override_agent.clone()),+ ..CreateThreadOptions::default()+ },+ AgentThreadSource::AgentPanel,+ window,+ cx,+ )+ });++ panel.read_with(&cx, |panel, _cx| {+ assert!(+ panel.retained_threads.contains_key(&override_id),+ "thread created with an agent override should also be retained"+ );+ assert_ne!(+ no_override_id, override_id,+ "each call should produce a distinct ThreadId"+ );+ assert_eq!(+ panel.selected_agent,+ Agent::Stub,+ "selected_agent should be restored to the original after an agent override"+ );+ });+ }}diff --git a/crates/feature_flags/src/flags.rs b/crates/feature_flags/src/flags.rsindex f6febdc5c4e..36e363ca40c 100644--- a/crates/feature_flags/src/flags.rs+++ b/crates/feature_flags/src/flags.rs@@ -71,6 +71,21 @@ impl FeatureFlag for UpdatePlanToolFeatureFlag {}register_feature_flag!(UpdatePlanToolFeatureFlag);+/// Gates the `create_thread` and `list_agents_and_models` tools, which let+/// the agent spawn independent sibling threads that show up in the agent+/// panel sidebar.+pub struct CreateThreadToolFeatureFlag;++impl FeatureFlag for CreateThreadToolFeatureFlag {+ const NAME: &'static str = "create-thread-tool";+ type Value = PresenceFlag;++ fn enabled_for_staff() -> bool {+ true+ }+}+register_feature_flag!(CreateThreadToolFeatureFlag);+pub struct UpdateTitleToolFeatureFlag;impl FeatureFlag for UpdateTitleToolFeatureFlag {diff --git a/crates/git_ui/src/worktree_service.rs b/crates/git_ui/src/worktree_service.rsindex a37b08bac76..8c0153c49ad 100644--- a/crates/git_ui/src/worktree_service.rs+++ b/crates/git_ui/src/worktree_service.rs@@ -9,7 +9,7 @@ use collections::HashSet;use fs::Fs;use gpui::{AsyncWindowContext, DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, SharedString,- TaskExt, WeakEntity,+ Task, TaskExt, WeakEntity,};use project::Project;use project::git_store::Repository;@@ -177,7 +177,7 @@ impl Render for WorktreeFetchFailedToast {cx.emit(DismissEvent);if let Some(workspace) = workspace_for_retry.upgrade() {workspace.update(cx, |workspace, cx| {- handle_create_worktree_inner(+ let task = create_worktree_workspace_inner(workspace,&zed_actions::CreateWorktree {worktree_name: worktree_name.clone(),@@ -186,8 +186,11 @@ impl Render for WorktreeFetchFailedToast {window,focused_dock,RemoteBranchFetchMode::UseLocal,+ // User-initiated retry of a foreground create.+ true,cx,);+ task.detach_and_log_err(cx);});}})),@@ -350,6 +353,14 @@ async fn fetch_remote_for_worktree_base(////// - `creation_infos`: a vec of `(repo, new_path, receiver)` tuples./// - `path_remapping`: `(old_work_dir, new_worktree_path)` pairs for remapping editor tabs.+///+/// Multiple entries in `git_repos` can be linked worktrees of the *same*+/// underlying repository (e.g. a project that has both the main checkout and+/// one of its linked worktrees open as separate Zed worktrees). Those entries+/// resolve to the same target path via [`Repository::path_for_new_linked_worktree`],+/// so we create the new worktree only once and remap every contributing+/// work directory onto it. Without this dedup, the second `git worktree add`+/// fails with "already exists".fn start_worktree_creations(git_repos: &[Entity<Repository>],worktree_name: Option<String>,@@ -369,6 +380,7 @@ fn start_worktree_creations()> {let mut creation_infos = Vec::new();let mut path_remapping = Vec::new();+ let mut scheduled_paths: HashSet<PathBuf> = HashSet::default();let worktree_name = worktree_name.unwrap_or_else(|| {let existing_refs: Vec<&str> = existing_worktree_names.iter().map(|s| s.as_str()).collect();@@ -383,15 +395,25 @@ fn start_worktree_creations(if existing_worktree_paths.contains(&new_path) {anyhow::bail!("A worktree already exists at {}", new_path.display());}- let target = git::repository::CreateWorktreeTarget::Detached {- base_sha: base_ref.clone(),- };- let receiver = repo.create_worktree(target, new_path.clone());let work_dir = repo.work_directory_abs_path.clone();+ // Only the first repo that resolves to a given target path+ // actually creates the worktree; subsequent linked worktrees of+ // the same repository just contribute a path remapping.+ let receiver = if scheduled_paths.contains(&new_path) {+ None+ } else {+ let target = git::repository::CreateWorktreeTarget::Detached {+ base_sha: base_ref.clone(),+ };+ Some(repo.create_worktree(target, new_path.clone()))+ };anyhow::Ok((work_dir, new_path, receiver))})?;path_remapping.push((work_dir.to_path_buf(), new_path.clone()));- creation_infos.push((repo.clone(), new_path, receiver));+ if let Some(receiver) = receiver {+ scheduled_paths.insert(new_path.clone());+ creation_infos.push((repo.clone(), new_path, receiver));+ }}Ok((creation_infos, path_remapping))@@ -561,6 +583,9 @@ fn maybe_propagate_worktree_trust(/// Handles the `CreateWorktree` action generically, without any agent panel involvement./// Creates a new git worktree, opens the workspace, restores layout and files.+/// Errors are surfaced to the user via toasts; the new workspace handle is+/// discarded. Use [`create_worktree_workspace`] when you need the resulting+/// workspace (e.g., the `create_thread` agent tool spawns a thread in it).pub fn handle_create_worktree(workspace: &mut Workspace,action: &zed_actions::CreateWorktree,@@ -568,38 +593,94 @@ pub fn handle_create_worktree(fallback_focused_dock: Option<DockPosition>,cx: &mut gpui::Context<Workspace>,) {- handle_create_worktree_inner(+ let task = create_worktree_workspace_inner(workspace,action,window,fallback_focused_dock,RemoteBranchFetchMode::Fetch,+ // The user explicitly asked to create a worktree, so foreground it.+ true,cx,);+ task.detach_and_log_err(cx);+}++/// Outcome of [`create_worktree_workspace`].+pub struct CreatedWorktreeWorkspace {+ /// The newly opened workspace.+ pub workspace: Entity<Workspace>,+ /// True when the project contained more than one Zed worktree backed by+ /// the same underlying git repository, so they were consolidated into a+ /// single new worktree (they resolve to the same target path). Callers+ /// that care — like the `create_thread` agent tool — can use this to warn+ /// that the result may not reflect every source worktree's state.+ pub consolidated_worktrees: bool,}-fn handle_create_worktree_inner(+/// Same as [`handle_create_worktree`], but returns a `Task` that resolves to+/// the new workspace once worktree creation and post-open setup are+/// complete. The caller receives errors as `Result`s and is expected to+/// handle them. Note that a small set of early failures (no git repositories,+/// disconnected remote, mid-creation `git fetch` failure) still surface a+/// toast on the source workspace so the user understands why the action+/// didn't take effect; the same error is also returned to the caller.+///+/// Used by the `create_thread` agent tool to spawn a sibling thread inside+/// the newly-opened workspace.+///+/// The new workspace is opened in the **background** (added as a retained+/// tab without switching to it or moving focus), and it's a clean checkout+/// rather than inheriting the source workspace's open files and dock layout.+/// This mirrors how the agent's non-worktree threads are created in the+/// background rather than yanking the user away from what they're doing.+pub fn create_worktree_workspace(+ workspace: &mut Workspace,+ action: &zed_actions::CreateWorktree,+ window: &mut gpui::Window,+ fallback_focused_dock: Option<DockPosition>,+ cx: &mut gpui::Context<Workspace>,+) -> Task<anyhow::Result<CreatedWorktreeWorkspace>> {+ create_worktree_workspace_inner(+ workspace,+ action,+ window,+ fallback_focused_dock,+ RemoteBranchFetchMode::Fetch,+ // Agent-created worktree workspaces open in the background.+ false,+ cx,+ )+}++fn create_worktree_workspace_inner(workspace: &mut Workspace,action: &zed_actions::CreateWorktree,window: &mut gpui::Window,fallback_focused_dock: Option<DockPosition>,remote_branch_fetch_mode: RemoteBranchFetchMode,+ activate: bool,cx: &mut gpui::Context<Workspace>,-) {+) -> Task<anyhow::Result<CreatedWorktreeWorkspace>> {let project = workspace.project().clone();if project.read(cx).repositories(cx).is_empty() {- log::error!("create_worktree: no git repository in the project");- return;+ return Task::ready(Err(anyhow!(+ "create_worktree: no git repository in the project"+ )));}if project.read(cx).is_via_collab() {- log::error!("create_worktree: not supported in collab projects");- return;+ return Task::ready(Err(anyhow!(+ "create_worktree: not supported in collab projects"+ )));}- // Guard against concurrent creation+ // Guard against concurrent creation. We treat a concurrent creation as+ // a hard error here so the caller can surface it; the user-facing+ // wrapper [`handle_create_worktree`] swallows the error via+ // `detach_and_log_err`, matching the pre-existing silent return.if workspace.active_worktree_creation().label.is_some() {- return;+ return Task::ready(Err(anyhow!("A worktree creation is already in progress")));}let previous_state =@@ -611,13 +692,14 @@ fn handle_create_worktree_inner(let (git_repos, non_git_paths) = classify_worktrees(project.read(cx), cx);if git_repos.is_empty() {+ let toast_workspace = cx.entity();show_error_toast(- cx.entity(),+ toast_workspace,"worktree create",anyhow!("No git repositories found in the project"),cx,);- return;+ return Task::ready(Err(anyhow!("No git repositories found in the project")));}if remote_connection_options.is_some() {@@ -626,13 +708,16 @@ fn handle_create_worktree_inner(.remote_client().is_some_and(|client| client.read(cx).is_disconnected());if is_disconnected {+ let toast_workspace = cx.entity();show_error_toast(- cx.entity(),+ toast_workspace,"worktree create",anyhow!("Cannot create worktree: remote connection is not active"),cx,);- return;+ return Task::ready(Err(anyhow!(+ "Cannot create worktree: remote connection is not active"+ )));}}@@ -677,6 +762,7 @@ fn handle_create_worktree_inner(workspace_handle.clone(),window_handle,remote_connection_options,+ activate,&mut cx,).await;@@ -707,7 +793,6 @@ fn handle_create_worktree_inner(result})- .detach_and_log_err(cx);}pub fn handle_switch_worktree(@@ -791,8 +876,9 @@ async fn do_create_worktree(workspace: WeakEntity<Workspace>,window_handle: Option<gpui::WindowHandle<MultiWorkspace>>,remote_connection_options: Option<RemoteConnectionOptions>,+ activate: bool,cx: &mut AsyncWindowContext,-) -> anyhow::Result<()> {+) -> anyhow::Result<CreatedWorktreeWorkspace> {// List existing worktrees from all repos to detect name collisionslet worktree_receivers: Vec<_> = cx.update(|_, cx| {git_repos@@ -874,11 +960,17 @@ async fn do_create_worktree(let created_paths = await_and_rollback_on_failure(creation_infos, fs, cx).await?;+ // `path_remapping` has one entry per source git repo, while `created_paths`+ // has one per *unique* target worktree. When the former is larger, two or+ // more source repos were linked worktrees of the same underlying+ // repository and `start_worktree_creations` consolidated them.+ let consolidated_worktrees = path_remapping.len() > created_paths.len();+let mut all_paths = created_paths;let has_non_git = !non_git_paths.is_empty();all_paths.extend(non_git_paths.iter().cloned());- open_worktree_workspace(+ let workspace = open_worktree_workspace(all_paths,path_remapping,non_git_paths,@@ -888,9 +980,15 @@ async fn do_create_worktree(window_handle,remote_connection_options,WorktreeOperation::Create,+ activate,cx,)- .await+ .await?;++ Ok(CreatedWorktreeWorkspace {+ workspace,+ consolidated_worktrees,+ })}async fn do_switch_worktree(@@ -902,7 +1000,7 @@ async fn do_switch_worktree(window_handle: Option<gpui::WindowHandle<MultiWorkspace>>,remote_connection_options: Option<RemoteConnectionOptions>,cx: &mut AsyncWindowContext,-) -> anyhow::Result<()> {+) -> anyhow::Result<Entity<Workspace>> {let path_remapping: Vec<(PathBuf, PathBuf)> = git_repo_work_dirs.iter().map(|work_dir| (work_dir.clone(), worktree_path.clone()))@@ -922,12 +1020,16 @@ async fn do_switch_worktree(window_handle,remote_connection_options,WorktreeOperation::Switch,+ // Switching is always an explicit, foreground user action.+ true,cx,).await}/// Core workspace opening logic shared by both create and switch flows.+/// Returns the newly opened workspace entity so callers can do post-open+/// work (e.g., the `create_thread` agent tool spawns a thread inside it).async fn open_worktree_workspace(all_paths: Vec<PathBuf>,path_remapping: Vec<(PathBuf, PathBuf)>,@@ -938,8 +1040,9 @@ async fn open_worktree_workspace(window_handle: Option<gpui::WindowHandle<MultiWorkspace>>,remote_connection_options: Option<RemoteConnectionOptions>,operation: WorktreeOperation,+ activate: bool,cx: &mut AsyncWindowContext,-) -> anyhow::Result<()> {+) -> anyhow::Result<Entity<Workspace>> {let window_handle = window_handle.ok_or_else(|| anyhow!("No window handle available for workspace creation"))?;@@ -947,7 +1050,14 @@ async fn open_worktree_workspace(let is_creating_new_worktree = matches!(operation, WorktreeOperation::Create);- let source_for_transfer = if is_creating_new_worktree {+ // When `activate` is false the new workspace is opened in the background+ // (e.g. the agent's `create_thread` tool), so it should be a clean+ // checkout rather than inheriting the source workspace's open files and+ // dock layout. The state transfer only applies when we're foregrounding+ // a freshly-created worktree for the user.+ let transfer_state = is_creating_new_worktree && activate;++ let source_for_transfer = if transfer_state {Some(workspace.clone())} else {None@@ -964,7 +1074,7 @@ async fn open_worktree_workspace(dyn FnOnce(&mut Workspace, &mut gpui::Window, &mut gpui::Context<Workspace>)+ Send,>,- > = if is_creating_new_worktree {+ > = if transfer_state {let dock_structure = previous_state.dock_structure;Some(Box::new(move |workspace: &mut Workspace,@@ -1034,7 +1144,7 @@ async fn open_worktree_workspace(maybe_propagate_worktree_trust(&workspace, &new_workspace, &all_paths, cx);- if is_creating_new_worktree {+ if transfer_state {window_handle.update(cx, |_multi_workspace, window, cx| {new_workspace.update(cx, |workspace, cx| {if has_non_git {@@ -1133,13 +1243,21 @@ async fn open_worktree_workspace(.ok();window_handle.update(cx, |multi_workspace, window, cx| {- multi_workspace.activate(new_workspace.clone(), source_for_transfer, window, cx);+ if activate {+ multi_workspace.activate(new_workspace.clone(), source_for_transfer, window, cx);+ } else {+ // Background open: register the new workspace as a retained tab+ // but leave the user where they are.+ multi_workspace.add_background_workspace(new_workspace.clone(), window, cx);+ }if is_creating_new_worktree {new_workspace.update(cx, |workspace, cx| {+ // Run create-worktree setup hooks regardless of foreground vs+ // background — the worktree was created either way.workspace.run_create_worktree_tasks(window, cx);- if let Some(dock_position) = focused_dock {+ if activate && let Some(dock_position) = focused_dock {let dock = workspace.dock_at_position(dock_position);if let Some(panel) = dock.read(cx).active_panel() {panel.panel_focus_handle(cx).focus(window, cx);@@ -1149,7 +1267,7 @@ async fn open_worktree_workspace(}})?;- anyhow::Ok(())+ Ok(new_workspace)}#[cfg(test)]diff --git a/crates/settings_ui/src/pages/tool_permissions_setup.rs b/crates/settings_ui/src/pages/tool_permissions_setup.rsindex 3122e63d2b6..8f010bc6b05 100644--- a/crates/settings_ui/src/pages/tool_permissions_setup.rs+++ b/crates/settings_ui/src/pages/tool_permissions_setup.rs@@ -1409,6 +1409,7 @@ mod tests {"get_code_actions","go_to_definition","grep",+ "list_agents_and_models","list_directory","open","read_file",@@ -1417,8 +1418,9 @@ mod tests {// streaming_edit_file uses "edit_file" for permission lookups,// so its rules are configured under the edit_file entry."streaming_edit_file",- // Subagent permission checks happen at the level of individual- // tool calls within the subagent, not at the spawning level.+ // Sibling/subagent thread creation delegates permission checks to+ // tool calls inside the spawned thread, not the spawning itself.+ "create_thread","spawn_agent",// update_plan updates UI-visible planning state but does not use// tool permission rules.diff --git a/crates/workspace/src/multi_workspace.rs b/crates/workspace/src/multi_workspace.rsindex 61344668eb2..ed652ef3745 100644--- a/crates/workspace/src/multi_workspace.rs+++ b/crates/workspace/src/multi_workspace.rs@@ -1504,6 +1504,29 @@ impl MultiWorkspace {cx.notify();}+ /// Adds `workspace` as a retained background tab without switching the+ /// active workspace to it or moving focus. Mirrors the registration and+ /// retention bookkeeping `activate` performs for the incoming workspace,+ /// but leaves the currently-active workspace focused.+ ///+ /// Used when something opens a workspace the user should not be yanked+ /// into — e.g. the agent's `create_thread` tool spawning a sibling+ /// worktree in the background.+ pub fn add_background_workspace(+ &mut self,+ workspace: Entity<Workspace>,+ window: &mut Window,+ cx: &mut Context<Self>,+ ) {+ if self.workspace() == &workspace || self.is_workspace_retained(&workspace) {+ return;+ }+ self.register_workspace(&workspace, window, cx);+ let key = workspace.read(cx).project_group_key(cx);+ self.retain_workspace(workspace, key, cx);+ cx.notify();+ }+/// Promotes the currently active workspace to persistent if it is/// transient, so it is retained across workspace switches even when/// the sidebar is closed. No-op if the workspace is already persistent.