Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
agent: Use receipts and reported state for native turns (#65420)
Ben Brandtd67bbfda3c01
diff --git a/crates/acp_thread/src/connection.rs b/crates/acp_thread/src/connection.rsindex 5264ce454c5..f90bbf17933 100644--- a/crates/acp_thread/src/connection.rs+++ b/crates/acp_thread/src/connection.rs@@ -210,13 +210,17 @@ pub trait AgentConnection {Ok(())}- /// This completion-based path retains a legacy response; receipt transports- /// acknowledge acceptance separately through `receipt_submissions`.+ /// Receipt transports acknowledge acceptance through `receipt_submissions`+ /// instead of implementing this completion-based path.fn prompt(&self,- params: acp_v2::PromptRequest,- cx: &mut App,- ) -> Task<Result<acp_v1::PromptResponse>>;+ _params: acp_v2::PromptRequest,+ _cx: &mut App,+ ) -> Task<Result<acp_v1::PromptResponse>> {+ Task::ready(Err(anyhow::anyhow!(+ "This agent does not support completion-based prompts"+ )))+ }fn retry(&self,diff --git a/crates/agent/src/agent.rs b/crates/agent/src/agent.rsindex 89c85f6a54f..c259ea64b38 100644--- a/crates/agent/src/agent.rs+++ b/crates/agent/src/agent.rs@@ -34,7 +34,6 @@ use acp_thread::{AgentSessionListRequest, AgentSessionListResponse, ClientUserMessageId, ProcessOutput,TokenUsageRatio,};-use agent_client_protocol::schema::v1 as acp_v1;use agent_client_protocol::schema::v2 as acp_v2;use agent_skills::{AGENTS_DIR_NAME, MAX_SKILL_DESCRIPTIONS_SIZE, MAX_SKILL_FILE_SIZE, ProjectSkillGroup,@@ -231,6 +230,8 @@ struct Session {thread: Entity<Thread>,/// The ACP thread that handles protocol communicationacp_thread: WeakEntity<acp_thread::AcpThread>,+ execution: Option<NativeExecution>,+ pending_cancellation: watch::Sender<()>,subagents: Vec<Entity<acp_thread::AcpThread>>,project_id: EntityId,/// Latest snapshot to persist. Overwritten in place on every save request;@@ -243,6 +244,144 @@ struct Session {_subscriptions: Vec<Subscription>,}+type NativeCompletion =+ Shared<oneshot::Receiver<std::result::Result<acp_v2::StopReason, Arc<anyhow::Error>>>>;++#[derive(Clone, Copy)]+enum NativeCancellation {+ InterruptedByFollowUp,+ Cancelled,+}++struct NativeExecution {+ _driver: Task<()>,+ message_id: ClientUserMessageId,+ retry_action: Option<NativeRetryAction>,+ cancellation: Option<oneshot::Sender<NativeCancellation>>,+ completion: NativeCompletion,+}++#[derive(Clone)]+enum NativeRetryAction {+ Prompt(Vec<acp_v2::ContentBlock>),+ Mcp {+ prompt_name: String,+ server_id: ContextServerId,+ arguments: HashMap<String, String>,+ content: Vec<acp_v2::ContentBlock>,+ },+ Skill {+ skill: Skill,+ content: Vec<acp_v2::ContentBlock>,+ },+ Compact,+}++impl NativeRetryAction {+ fn for_prompt(+ content: Vec<acp_v2::ContentBlock>,+ project_state: &ProjectState,+ cx: &App,+ ) -> Self {+ if let Some(parsed_command) = Command::parse(&content) {+ if parsed_command.is_unqualified(COMPACT_COMMAND_NAME) {+ return Self::Compact;+ }++ // Skill scope qualifiers (`/:<name>` and+ // `/<worktree>:<name>`) use a colon separator that can't+ // collide with MCP's `/<server>.<name>` grammar. The popup+ // inserts a qualified form for every skill so picking the+ // global row unambiguously runs the global skill even when+ // a same-named project-local one exists.+ if let Some(scope) = parsed_command.skill_scope+ && let Some(skill) = project_state.skills.iter().find(|skill| {+ skill.name == parsed_command.prompt_name && skill.source.matches_scope(scope)+ })+ {+ return Self::Skill {+ skill: skill.clone(),+ content,+ };+ }++ // MCP prompts and skills both register slash commands. MCP+ // prompts are checked first — if a user has both an MCP prompt+ // and a skill with the same name, the MCP prompt wins (matching+ // the order they appear in the catalog).+ let registry = project_state.context_server_registry.read(cx);+ let explicit_server_id = parsed_command+ .explicit_server_id+ .map(|server_id| ContextServerId(server_id.into()));++ if let Some(prompt) =+ registry.find_prompt(explicit_server_id.as_ref(), parsed_command.prompt_name)+ {+ let arguments = if !parsed_command.arg_value.is_empty()+ && let Some(arg_name) = prompt+ .prompt+ .arguments+ .as_ref()+ .and_then(|args| args.first())+ .map(|arg| arg.name.clone())+ {+ HashMap::from_iter([(arg_name, parsed_command.arg_value.to_string())])+ } else {+ Default::default()+ };+ return Self::Mcp {+ prompt_name: prompt.prompt.name.clone(),+ server_id: prompt.server_id.clone(),+ arguments,+ content,+ };+ }++ // Unqualified skill match (`/skill-name` with no scope+ // prefix and no MCP server prefix). Slash commands work+ // for *all* skills regardless of `disable_model_invocation`+ // — that flag only hides the skill from the model's catalog.+ // The user explicitly typed the name, so they get to invoke+ // it.+ //+ // Inlined rather than calling `apply_skill_overrides` so+ // we don't clone the entire skill list on every prompt+ // (including prompts like `/help` that aren't skills at+ // all). The resolution rule matches the override-applied+ // view: among skills with the matching name, pick the one+ // with the highest source precedence, so the slash command+ // picks the same entry the model sees in its catalog.+ // Ties (e.g. two project-local skills from different+ // worktrees) resolve to the first in iteration order to+ // match `apply_skill_overrides`.+ if parsed_command.explicit_server_id.is_none()+ && parsed_command.skill_scope.is_none()+ && !project_state.skills.is_empty()+ {+ let prompt_name = parsed_command.prompt_name;+ let resolved = project_state+ .skills+ .iter()+ .filter(|skill| skill.name == prompt_name)+ .reduce(|best, candidate| {+ if candidate.source.precedence() > best.source.precedence() {+ candidate+ } else {+ best+ }+ });+ if let Some(skill) = resolved {+ return Self::Skill {+ skill: skill.clone(),+ content,+ };+ }+ }+ }+ Self::Prompt(content)+ }+}+impl Session {fn draft_prompt(&self, cx: &App) -> Option<Vec<acp_v2::ContentBlock>> {match self.acp_thread.upgrade() {@@ -874,9 +1013,27 @@ impl NativeAgent {let subscriptions = vec![cx.subscribe(&thread_handle, Self::handle_thread_title_updated),cx.subscribe(&thread_handle, Self::handle_thread_token_usage_updated),+ cx.subscribe(+ &thread_handle,+ |this, thread, _: &crate::thread::CancellationRequested, cx| {+ this.cancel_session(thread.read(cx).id());+ },+ ),cx.observe(&thread_handle, move |this, thread, cx| {this.save_thread(thread, cx)}),+ cx.subscribe(&acp_thread, |_this, thread, event, cx| {+ if matches!(+ event,+ acp_thread::AcpThreadEvent::ToolAuthorizationRequested(_)+ | acp_thread::AcpThreadEvent::ToolAuthorizationReceived(_)+ | acp_thread::AcpThreadEvent::ElicitationRequested(_)+ | acp_thread::AcpThreadEvent::ElicitationResponded(_)+ | acp_thread::AcpThreadEvent::EntriesRemoved(_)+ ) {+ thread.update(cx, |thread, cx| thread.sync_local_action_state(cx));+ }+ }),cx.observe_release(&acp_thread, {let session_id = session_id.clone();let acp_thread_id = acp_thread.entity_id();@@ -912,6 +1069,8 @@ impl NativeAgent {Session {thread: thread_handle,acp_thread: acp_thread.downgrade(),+ execution: None,+ pending_cancellation: watch::channel(()).0,subagents: Vec::new(),project_id,pending_save,@@ -928,6 +1087,21 @@ impl NativeAgent {acp_thread}+ fn cancel_session(&mut self, session_id: &acp_v2::SessionId) {+ let Some(session) = self.sessions.get_mut(session_id) else {+ return;+ };+ if session.pending_cancellation.send(()).is_err() {+ log::debug!("No pending native submissions to cancel");+ }+ if let Some(execution) = session.execution.as_mut()+ && let Some(sender) = execution.cancellation.take()+ && sender.send(NativeCancellation::Cancelled).is_err()+ {+ log::debug!("Native execution already completed");+ }+ }+pub fn models(&self) -> &LanguageModels {&self.models}@@ -1956,8 +2130,34 @@ impl NativeAgent {}}+ fn mark_execution_history_prepared(&mut self, session_id: &acp_v2::SessionId) -> Result<()> {+ let execution = self+ .sessions+ .get_mut(session_id)+ .and_then(|session| session.execution.as_mut())+ .context("Native execution not found")?;+ if !matches!(execution.retry_action, Some(NativeRetryAction::Compact)) {+ execution.retry_action = None;+ }+ Ok(())+ }++ fn set_execution_retry_action(+ &mut self,+ session_id: &acp_v2::SessionId,+ retry_action: NativeRetryAction,+ ) -> Result<()> {+ let execution = self+ .sessions+ .get_mut(session_id)+ .and_then(|session| session.execution.as_mut())+ .context("Native execution not found")?;+ execution.retry_action = Some(retry_action);+ Ok(())+ }+fn send_mcp_prompt(- &self,+ &mut self,client_user_message_id: ClientUserMessageId,session_id: acp_v2::SessionId,prompt_name: String,@@ -1965,7 +2165,18 @@ impl NativeAgent {arguments: HashMap<String, String>,original_content: Vec<acp_v2::ContentBlock>,cx: &mut Context<Self>,- ) -> Task<Result<acp_v1::PromptResponse>> {+ ) -> Task<Result<acp_v2::StopReason>> {+ if let Err(error) = self.set_execution_retry_action(+ &session_id,+ NativeRetryAction::Mcp {+ prompt_name: prompt_name.clone(),+ server_id: server_id.clone(),+ arguments: arguments.clone(),+ content: original_content.clone(),+ },+ ) {+ return Task::ready(Err(error));+ }let Some(state) = self.session_project_state(&session_id) else {return Task::ready(Err(anyhow!("Project state not found for session")));};@@ -1989,7 +2200,6 @@ impl NativeAgent {})??;let mut last_is_user = true;-thread.update(cx, |thread, cx| {thread.push_acp_user_block(client_user_message_id,@@ -2006,20 +2216,19 @@ impl NativeAgent {match role {context_server::types::Role::User => {- let id = acp_thread::ClientUserMessageId::new();+ let id = ClientUserMessageId::new();+ thread.update(cx, |thread, cx| {+ thread.push_acp_user_block(id.clone(), [block], path_style, cx)+ })?;acp_thread.update(cx, |acp_thread, cx| {acp_thread.push_user_content_block_with_indent(- Some(id.clone()),+ Some(id),display_block,true,cx,);})?;-- thread.update(cx, |thread, cx| {- thread.push_acp_user_block(id, [block], path_style, cx)- })?;}context_server::types::Role::Assistant => {acp_thread.update(cx, |acp_thread, cx| {@@ -2038,6 +2247,9 @@ impl NativeAgent {last_is_user = role == context_server::types::Role::User;}+ this.update(cx, |this, _cx| {+ this.mark_execution_history_prepared(&session_id)+ })??;let response_stream = thread.update(cx, |thread, cx| {if last_is_user {thread.send_existing(cx)@@ -2047,7 +2259,7 @@ impl NativeAgent {}})?;- let connection = this.upgrade().map(NativeAgentConnection);+ let connection = Some(this.clone());cx.update(|cx| {NativeAgentConnection::handle_thread_events(response_stream,@@ -2067,7 +2279,7 @@ impl NativeAgent {client_user_message_id: ClientUserMessageId,session_id: acp_v2::SessionId,cx: &mut Context<Self>,- ) -> Task<Result<acp_v1::PromptResponse>> {+ ) -> Task<Result<acp_v2::StopReason>> {cx.spawn(async move |this, cx| {let (acp_thread, thread) = this.update(cx, |this, _cx| {let session = this@@ -2083,7 +2295,7 @@ impl NativeAgent {acp_thread.update_token_usage(None, cx);})?;- let connection = this.upgrade().map(NativeAgentConnection);+ let connection = Some(this.clone());cx.update(|cx| {NativeAgentConnection::handle_thread_events(response_stream,@@ -2105,13 +2317,22 @@ impl NativeAgent {/// message after the skill envelope, so the model sees the skill/// instructions followed by the user's request.fn send_skill_invocation(- &self,+ &mut self,client_user_message_id: ClientUserMessageId,session_id: acp_v2::SessionId,skill: Skill,original_content: Vec<acp_v2::ContentBlock>,cx: &mut Context<Self>,- ) -> Task<Result<acp_v1::PromptResponse>> {+ ) -> Task<Result<acp_v2::StopReason>> {+ if let Err(error) = self.set_execution_retry_action(+ &session_id,+ NativeRetryAction::Skill {+ skill: skill.clone(),+ content: original_content.clone(),+ },+ ) {+ return Task::ready(Err(error));+ }let Some(state) = self.session_project_state(&session_id) else {return Task::ready(Err(anyhow!("Project state not found for session")));};@@ -2186,9 +2407,12 @@ impl NativeAgent {thread.push_acp_user_block(client_user_message_id, combined, path_style, cx)})?;+ this.update(cx, |this, _cx| {+ this.mark_execution_history_prepared(&session_id)+ })??;let response_stream = thread.update(cx, |thread, cx| thread.send_existing(cx))?;- let connection = this.upgrade().map(NativeAgentConnection);+ let connection = Some(this.clone());cx.update(|cx| {NativeAgentConnection::handle_thread_events(response_stream,@@ -2263,13 +2487,320 @@ impl NativeAgentConnection {.update(cx, |this, cx| this.load_thread(id, project, cx))}+ pub fn send_and_wait_for_completion(+ &self,+ thread: Entity<AcpThread>,+ content: Vec<acp_v2::ContentBlock>,+ cx: &mut App,+ ) -> Task<Result<acp_v2::StopReason>> {+ let session_id = thread.read(cx).session_id().clone();+ let (receipt, completion) = self.submit_native(session_id, Some(content.clone()), cx);+ let submission =+ thread.update(cx, |thread, cx| thread.submit_receipt(content, receipt, cx));+ cx.spawn(async move |_cx| {+ if submission.await?.is_none() {+ return Ok(acp_v2::StopReason::Cancelled);+ }+ completion.await?.map_err(|error| anyhow!("{error:#}"))+ })+ }++ fn submit_native(+ &self,+ session_id: acp_v2::SessionId,+ content: Option<Vec<acp_v2::ContentBlock>>,+ cx: &mut App,+ ) -> (Task<Result<acp_v2::PromptResponse>>, NativeCompletion) {+ let (completion_sender, completion_receiver) = oneshot::channel();+ let completion = completion_receiver.shared();+ if let Some(content) = &content+ && let Err(error) = acp_thread::AgentConnection::validate_prompt_content(self, content)+ {+ return (Task::ready(Err(error)), completion);+ }++ // Subscribe before spawning so cancellation also fences receipts that+ // have not yet been polled. A later submission gets a fresh subscription.+ let Some(mut cancellation) = self+ .0+ .read(cx)+ .sessions+ .get(&session_id)+ .map(|session| session.pending_cancellation.receiver())+ else {+ return (Task::ready(Err(anyhow!("Session not found"))), completion);+ };+ let agent = self.0.downgrade();+ let driver_completion = completion.clone();+ let receipt = cx.spawn(async move |cx| {+ let acceptance = async move {+ // Recheck after each wait: another queued submission may have accepted+ // a successor while this one was waiting for the previous driver.+ loop {+ let previous = agent.update(cx, |agent, _cx| -> Result<_> {+ let session = agent+ .sessions+ .get_mut(&session_id)+ .context("Session not found")?;+ let Some(execution) = &mut session.execution else {+ return Ok(None);+ };+ if execution.completion.peek().is_some() {+ return Ok(None);+ }+ if let Some(sender) = execution.cancellation.take()+ && sender+ .send(NativeCancellation::InterruptedByFollowUp)+ .is_err()+ {+ log::debug!("Native execution already completed");+ }+ Ok(Some(execution.completion.clone()))+ })??;+ let Some(previous) = previous else {+ break;+ };+ if let Err(error) = previous+ .await+ .context("Previous native execution was released")?+ {+ log::debug!("Previous native execution failed: {error:#}");+ }+ }++ cx.update(|cx| -> Result<_> {+ let (acp_thread, thread, previous_execution) =+ agent.read_with(cx, |agent, _cx| {+ let session = agent+ .sessions+ .get(&session_id)+ .context("Session not found")?;+ Ok::<_, anyhow::Error>((+ session+ .acp_thread+ .upgrade()+ .context("Session was released")?,+ session.thread.clone(),+ session.execution.as_ref().map(|execution| {+ (execution.message_id.clone(), execution.retry_action.clone())+ }),+ ))+ })??;+ let (message_id, preparation, retry_action) = if let Some(content) = content {+ let message_id = ClientUserMessageId::new();+ let retry_action = agent.read_with(cx, |agent, cx| {+ let project_state = agent+ .session_project_state(&session_id)+ .context("Project state not found for session")?;+ anyhow::Ok(NativeRetryAction::for_prompt(+ content.clone(),+ project_state,+ cx,+ ))+ })??;+ let source = if matches!(retry_action, NativeRetryAction::Compact) {+ Vec::new()+ } else {+ content+ };+ let path_style = thread.read(cx).project().read(cx).path_style(cx);+ thread.update(cx, |thread, cx| {+ thread.prepare_local_turn(cx);+ // The receipt needs a retained rewind target, but a command+ // must not enter provider history until preparation succeeds.+ let history_content = match &retry_action {+ NativeRetryAction::Prompt(content) => content.clone(),+ _ => Vec::new(),+ };+ thread.push_acp_user_block(+ message_id.clone(),+ history_content,+ path_style,+ cx,+ )+ })?;+ let preparation = acp_thread.update(cx, |thread, cx| {+ thread.prepare_local_prompt(message_id.clone(), source, cx)+ })?;+ (message_id, preparation, Some(retry_action))+ } else {+ let previous_execution = previous_execution+ .filter(|(id, _retry_action)| thread.read(cx).has_user_message(id));+ let message_id = previous_execution+ .as_ref()+ .map(|(id, _retry_action)| id.clone())+ .or_else(|| thread.read(cx).last_user_message_id())+ .context("No user message to retry")?;+ let retry_action =+ previous_execution.and_then(|(_id, retry_action)| retry_action);+ thread.update(cx, |thread, cx| thread.prepare_local_turn(cx));+ (message_id, Task::ready(()), retry_action)+ };+ let (cancellation_sender, cancellation_receiver) = oneshot::channel();+ let driver = Self::drive_execution(+ agent.clone(),+ session_id.clone(),+ thread,+ acp_thread.downgrade(),+ message_id.clone(),+ retry_action.clone(),+ preparation,+ cancellation_receiver,+ completion_sender,+ cx,+ );+ agent.update(cx, |agent, _cx| -> Result<()> {+ let session = agent+ .sessions+ .get_mut(&session_id)+ .context("Session not found")?;+ session.execution = Some(NativeExecution {+ _driver: driver,+ message_id: message_id.clone(),+ retry_action,+ cancellation: Some(cancellation_sender),+ completion: driver_completion,+ });+ Ok(())+ })??;+ acp_thread.update(cx, |thread, cx| {+ thread.update_session_state(+ acp_v2::StateUpdate::Running(acp_v2::RunningStateUpdate::new()),+ cx,+ )+ })?;+ Ok(acp_v2::PromptResponse::new(message_id.message_id()))+ })+ };+ futures::pin_mut!(acceptance);+ futures::select_biased! {+ cancelled = cancellation.changed().fuse() => {+ cancelled.context("Session was released")?;+ Err(acp_thread::SubmissionCancelled.into())+ },+ response = acceptance.fuse() => response,+ }+ });+ (receipt, completion)+ }++ fn drive_execution(+ agent: WeakEntity<NativeAgent>,+ session_id: acp_v2::SessionId,+ thread: Entity<Thread>,+ acp_thread: WeakEntity<AcpThread>,+ message_id: ClientUserMessageId,+ retry_action: Option<NativeRetryAction>,+ preparation: Task<()>,+ cancellation: oneshot::Receiver<NativeCancellation>,+ completion: oneshot::Sender<std::result::Result<acp_v2::StopReason, Arc<anyhow::Error>>>,+ cx: &App,+ ) -> Task<()> {+ cx.spawn(async move |cx| {+ let execution = cx.spawn({+ let agent = agent.clone();+ async move |cx| {+ preparation.await;+ let task = cx.update(|cx| -> Result<_> {+ let connection = NativeAgentConnection(+ agent.upgrade().context("Native agent was released")?,+ );+ Ok(connection.execute_retry_action(session_id, message_id, retry_action, cx))+ })?;+ task.await+ }+ });+ let mut execution = execution.fuse();+ let result = futures::select_biased! {+ cancellation = cancellation.fuse() => {+ let cancellation = cancellation.unwrap_or(NativeCancellation::Cancelled);+ let model_started = !thread.read_with(cx, |thread, _cx| thread.is_turn_complete());+ // Tools may ignore cancellation. Their native cleanup must not+ // delay the bridge's Stop event or the next accepted prompt.+ thread.update(cx, |thread, cx| thread.cancel(cx)).detach();+ if model_started {+ // Drain cancellation updates (including compaction terminalization)+ // before publishing Idle or allowing another submission to insert.+ if let Err(error) = execution.await {+ log::debug!("Native cancellation drain: {error:#}");+ }+ } else {+ drop(execution);+ }+ acp_thread.update(cx, |thread, cx| {+ thread.cancel_local_actions(match cancellation {+ NativeCancellation::InterruptedByFollowUp =>+ acp_thread::RequestPermissionOutcome::InterruptedByFollowUp,+ NativeCancellation::Cancelled =>+ acp_thread::RequestPermissionOutcome::Cancelled,+ }, cx);+ }).log_err();+ Ok(acp_v2::StopReason::Cancelled)+ },+ result = execution => result,+ };+ if result.is_err() {+ acp_thread.update(cx, |thread, cx| {+ thread.cancel_local_actions(acp_thread::RequestPermissionOutcome::Cancelled, cx);+ }).log_err();+ thread.update(cx, |thread, cx| thread.cancel(cx)).detach();+ }+ let result = match result {+ Ok(reason) => {+ let finish = acp_thread.update(cx, |thread, cx| {+ thread.finish_local_turn(reason.clone(), cx)+ });+ match finish {+ Ok(finish) => match finish.await {+ Ok(()) => acp_thread.update(cx, |thread, cx| {+ thread.update_session_state(+ acp_v2::StateUpdate::Idle(+ acp_v2::IdleStateUpdate::new().stop_reason(reason.clone()),+ ),+ cx,+ )+ }).and_then(|result| result).map(|()| reason),+ Err(error) => Err(error),+ },+ Err(error) => Err(error),+ }+ }+ Err(error) => {+ let finish = acp_thread.update(cx, |thread, cx| {+ thread.finish_local_turn(acp_v2::ErrorStopReason::new().into(), cx)+ });+ match finish {+ Ok(finish) => {+ finish.await.log_err();+ }+ Err(finish_error) => log::error!("Native error cleanup: {finish_error:#}"),+ }+ Err(error)+ }+ };+ let result = match result {+ Ok(reason) => Ok(reason),+ Err(error) => {+ let error = Arc::new(error);+ acp_thread.update(cx, |thread, cx| {+ thread.report_local_execution_error(error.clone(), cx)+ }).and_then(|result| result).log_err();+ Err(error)+ }+ };+ if completion.send(result).is_err() {+ log::debug!("Native completion observer was dropped");+ }+ })+ }+fn run_turn(&self,session_id: acp_v2::SessionId,cx: &mut App,f: impl 'static+ FnOnce(Entity<Thread>, &mut App) -> Result<mpsc::UnboundedReceiver<Result<ThreadEvent>>>,- ) -> Task<Result<acp_v1::PromptResponse>> {+ ) -> Task<Result<acp_v2::StopReason>> {let Some((thread, acp_thread)) = self.0.update(cx, |agent, _cx| {let session = agent.sessions.get(&session_id)?;Some((session.thread.clone(), session.acp_thread.clone()))@@ -2283,15 +2814,15 @@ impl NativeAgentConnection {Ok(stream) => stream,Err(err) => return Task::ready(Err(err)),};- Self::handle_thread_events(response_stream, acp_thread, Some(self.clone()), cx)+ Self::handle_thread_events(response_stream, acp_thread, Some(self.0.downgrade()), cx)}fn handle_thread_events(mut events: mpsc::UnboundedReceiver<Result<ThreadEvent>>,acp_thread: WeakEntity<AcpThread>,- connection: Option<NativeAgentConnection>,+ connection: Option<WeakEntity<NativeAgent>>,cx: &App,- ) -> Task<Result<acp_v1::PromptResponse>> {+ ) -> Task<Result<acp_v2::StopReason>> {cx.spawn(async move |cx| {// Handle response stream and forward to session.acp_threadwhile let Some(result) = events.next().await {@@ -2305,14 +2836,8 @@ impl NativeAgentConnection {.map(acp_v2::ContentBlock::from).collect::<Vec<_>>();acp_thread.update(cx, |thread, cx| {- for content in content {- thread.push_user_content_block(- Some(message.id.clone()),- content,- cx,- );- }- })?;+ thread.upsert_local_user_message(message.id, content, cx)+ })??;}ThreadEvent::AgentText(text) => {acp_thread.update(cx, |thread, cx| {@@ -2423,9 +2948,9 @@ impl NativeAgentConnection {{if let Some(connection) = &connection {cx.update(|cx| {- connection.0.update(cx, |agent, _| {+ connection.update(cx, |agent, _| {agent.models.notify_model_selection_changed();- });+ }).log_err();});}}@@ -2445,7 +2970,7 @@ impl NativeAgentConnection {}ThreadEvent::Stop(stop_reason) => {log::debug!("Assistant message complete: {:?}", stop_reason);- return legacy_native_completion(stop_reason);+ return Ok(stop_reason);}}}@@ -2457,31 +2982,11 @@ impl NativeAgentConnection {}log::debug!("Response stream completed");- anyhow::Ok(acp_v1::PromptResponse::new(acp_v1::StopReason::EndTurn))+ anyhow::Ok(acp_v2::StopReason::EndTurn)})}}-fn legacy_native_completion(stop_reason: acp_v2::StopReason) -> Result<acp_v1::PromptResponse> {- // Native events are version-neutral, but the completion-based connection API- // still returns a v1 response. This is not a v2 acceptance receipt.- let stop_reason = match stop_reason {- acp_v2::StopReason::EndTurn => acp_v1::StopReason::EndTurn,- acp_v2::StopReason::MaxTokens => acp_v1::StopReason::MaxTokens,- acp_v2::StopReason::MaxTurnRequests => acp_v1::StopReason::MaxTurnRequests,- acp_v2::StopReason::Refusal => acp_v1::StopReason::Refusal,- acp_v2::StopReason::Cancelled => acp_v1::StopReason::Cancelled,- acp_v2::StopReason::Error(reason) => {- return Err(match reason.error {- Some(error) => anyhow::Error::new(*error),- None => anyhow!("Native agent stopped with an error"),- });- }- _ => anyhow::bail!("Native agent returned an unsupported stop reason"),- };- Ok(acp_v1::PromptResponse::new(stop_reason))-}-struct Command<'a> {prompt_name: &'a str,arg_value: &'a str,@@ -2798,6 +3303,33 @@ pub fn available_native_agent(cx: &App) -> AvailableAgent {}}+struct NativeSessionSubmissions {+ connection: NativeAgentConnection,+ session_id: acp_v2::SessionId,+}++impl acp_thread::ReceiptSessionSubmissions for NativeSessionSubmissions {+ fn prompt(+ &self,+ content: Vec<acp_v2::ContentBlock>,+ cx: &mut App,+ ) -> Task<Result<acp_v2::PromptResponse>> {+ self.connection+ .submit_native(self.session_id.clone(), Some(content), cx)+ .0+ }++ fn supports_retry(&self) -> bool {+ true+ }++ fn retry(&self, cx: &mut App) -> Task<Result<acp_v2::PromptResponse>> {+ self.connection+ .submit_native(self.session_id.clone(), None, cx)+ .0+ }+}+impl acp_thread::AgentConnection for NativeAgentConnection {fn agent_id(&self) -> AgentId {ZED_AGENT_ID.clone()@@ -2850,12 +3382,15 @@ impl acp_thread::AgentConnection for NativeAgentConnection {}) as Rc<dyn AgentModelSelector>)}- fn client_user_message_ids(+ fn receipt_submissions(&self,+ session_id: &acp_v2::SessionId,_cx: &App,- ) -> Option<Rc<dyn acp_thread::AgentSessionClientUserMessageIds>> {- let prompt: Rc<dyn acp_thread::AgentSessionClientUserMessageIds> = Rc::new(self.clone());- Some(prompt)+ ) -> Option<Rc<dyn acp_thread::ReceiptSessionSubmissions>> {+ Some(Rc::new(NativeSessionSubmissions {+ connection: self.clone(),+ session_id: session_id.clone(),+ }))}fn validate_prompt_content(&self, content: &[acp_v2::ContentBlock]) -> Result<()> {@@ -2864,39 +3399,10 @@ impl acp_thread::AgentConnection for NativeAgentConnection {.try_for_each(UserMessageContent::validate_content_block)}- fn prompt(- &self,- params: acp_v2::PromptRequest,- cx: &mut App,- ) -> Task<Result<acp_v1::PromptResponse>> {- acp_thread::AgentSessionClientUserMessageIds::prompt(- self,- acp_thread::AgentSessionClientUserMessageIds::new_id(self),- params,- cx,- )- }-- fn retry(- &self,- session_id: &acp_v2::SessionId,- _cx: &App,- ) -> Option<Rc<dyn acp_thread::AgentSessionRetry>> {- Some(Rc::new(NativeAgentSessionRetry {- connection: self.clone(),- session_id: session_id.clone(),- }) as _)- }-fn cancel(&self, session_id: &acp_v2::SessionId, cx: &mut App) {log::info!("Cancelling on session: {}", session_id);- self.0.update(cx, |agent, cx| {- if let Some(session) = agent.sessions.get(session_id) {- session- .thread- .update(cx, |thread, cx| thread.cancel(cx))- .detach();- }+ self.0.update(cx, |agent, _cx| {+ agent.cancel_session(session_id);});}@@ -2947,13 +3453,54 @@ impl acp_thread::AgentConnection for NativeAgentConnection {}}-impl acp_thread::AgentSessionClientUserMessageIds for NativeAgentConnection {- fn prompt(+impl NativeAgentConnection {+ fn execute_retry_action(+ &self,+ session_id: acp_v2::SessionId,+ message_id: ClientUserMessageId,+ retry_action: Option<NativeRetryAction>,+ cx: &mut App,+ ) -> Task<Result<acp_v2::StopReason>> {+ match retry_action {+ Some(NativeRetryAction::Prompt(content)) => self.execute_prompt(+ message_id,+ acp_v2::PromptRequest::new(session_id, content),+ cx,+ ),+ Some(NativeRetryAction::Mcp {+ prompt_name,+ server_id,+ arguments,+ content,+ }) => self.0.update(cx, |agent, cx| {+ agent.send_mcp_prompt(+ message_id,+ session_id,+ prompt_name,+ server_id,+ arguments,+ content,+ cx,+ )+ }),+ Some(NativeRetryAction::Skill { skill, content }) => self.0.update(cx, |agent, cx| {+ agent.send_skill_invocation(message_id, session_id, skill, content, cx)+ }),+ Some(NativeRetryAction::Compact) => self.0.update(cx, |agent, cx| {+ agent.send_compact_command(message_id, session_id, cx)+ }),+ None => self.run_turn(session_id, cx, |thread, cx| {+ thread.update(cx, |thread, cx| thread.resume(cx))+ }),+ }+ }++ fn execute_prompt(&self,client_user_message_id: acp_thread::ClientUserMessageId,params: acp_v2::PromptRequest,cx: &mut App,- ) -> Task<Result<acp_v1::PromptResponse>> {+ ) -> Task<Result<acp_v2::StopReason>> {let session_id = params.session_id.clone();log::info!("Received prompt request for session: {}", session_id);log::debug!("Prompt blocks count: {}", params.prompt.len());@@ -2975,127 +3522,9 @@ impl acp_thread::AgentSessionClientUserMessageIds for NativeAgentConnection {return Task::ready(Err(error));}- if let Some(parsed_command) = Command::parse(¶ms.prompt) {- if parsed_command.is_unqualified(COMPACT_COMMAND_NAME) {- return self.0.update(cx, |agent, cx| {- agent.send_compact_command(client_user_message_id, session_id, cx)- });- }-- // Skill scope qualifiers (`/:<name>` and- // `/<worktree>:<name>`) use a colon separator that can't- // collide with MCP's `/<server>.<name>` grammar. The popup- // inserts a qualified form for every skill so picking the- // global row unambiguously runs the global skill even when- // a same-named project-local one exists.- if let Some(scope) = parsed_command.skill_scope- && let Some(skill) = project_state.skills.iter().find(|skill| {- skill.name == parsed_command.prompt_name && skill.source.matches_scope(scope)- })- {- let skill = skill.clone();- return self.0.update(cx, |agent, cx| {- agent.send_skill_invocation(- client_user_message_id,- session_id.clone(),- skill,- params.prompt,- cx,- )- });- }-- // MCP prompts and skills both register slash commands. MCP- // prompts are checked first — if a user has both an MCP prompt- // and a skill with the same name, the MCP prompt wins (matching- // the order they appear in the catalog).- let registry = project_state.context_server_registry.read(cx);-- let explicit_server_id = parsed_command- .explicit_server_id- .map(|server_id| ContextServerId(server_id.into()));-- if let Some(prompt) =- registry.find_prompt(explicit_server_id.as_ref(), parsed_command.prompt_name)- {- let arguments = if !parsed_command.arg_value.is_empty()- && let Some(arg_name) = prompt- .prompt- .arguments- .as_ref()- .and_then(|args| args.first())- .map(|arg| arg.name.clone())- {- HashMap::from_iter([(arg_name, parsed_command.arg_value.to_string())])- } else {- Default::default()- };-- let prompt_name = prompt.prompt.name.clone();- let server_id = prompt.server_id.clone();-- return self.0.update(cx, |agent, cx| {- agent.send_mcp_prompt(- client_user_message_id,- session_id.clone(),- prompt_name,- server_id,- arguments,- params.prompt,- cx,- )- });- }-- // Unqualified skill match (`/skill-name` with no scope- // prefix and no MCP server prefix). Slash commands work- // for *all* skills regardless of `disable_model_invocation`- // — that flag only hides the skill from the model's catalog.- // The user explicitly typed the name, so they get to invoke- // it.- //- // Inlined rather than calling `apply_skill_overrides` so- // we don't clone the entire skill list on every prompt- // (including prompts like `/help` that aren't skills at- // all). The resolution rule matches the override-applied- // view: among skills with the matching name, pick the one- // with the highest source precedence, so the slash command- // picks the same entry the model sees in its catalog.- // Ties (e.g. two project-local skills from different- // worktrees) resolve to the first in iteration order to- // match `apply_skill_overrides`.- if parsed_command.explicit_server_id.is_none()- && parsed_command.skill_scope.is_none()- && !project_state.skills.is_empty()- {- let prompt_name = parsed_command.prompt_name;- let resolved = project_state- .skills- .iter()- .filter(|skill| skill.name == prompt_name)- .reduce(|best, candidate| {- if candidate.source.precedence() > best.source.precedence() {- candidate- } else {- best- }- });- if let Some(skill) = resolved {- let skill = skill.clone();- return self.0.update(cx, |agent, cx| {- agent.send_skill_invocation(- client_user_message_id,- session_id.clone(),- skill,- params.prompt,- cx,- )- });- }- }- };-let path_style = project_state.project.read(cx).path_style(cx);+ let agent = self.0.downgrade();+ let prepared_session_id = session_id.clone();self.run_turn(session_id, cx, move |thread, cx| {let content = params.prompt@@ -3107,8 +3536,12 @@ impl acp_thread::AgentSessionClientUserMessageIds for NativeAgentConnection {log::debug!("Message content: {:?}", content);thread.update(cx, |thread, cx| {- thread.send(client_user_message_id, content, cx)- })+ thread.upsert_user_message(client_user_message_id, content.into(), cx)+ });+ agent.update(cx, |agent, _cx| {+ agent.mark_execution_history_prepared(&prepared_session_id)+ })??;+ thread.update(cx, |thread, cx| thread.send_existing(cx))})}}@@ -3217,34 +3650,24 @@ impl acp_thread::AgentSessionTruncate for NativeAgentSessionTruncate {client_user_message_id: acp_thread::ClientUserMessageId,cx: &mut App,) -> Task<Result<()>> {- match self.thread.update(cx, |thread, cx| {- thread.truncate(client_user_message_id.clone(), cx)?;- Ok(thread.latest_token_usage())- }) {- Ok(usage) => {- self.acp_thread- .update(cx, |thread, cx| {- thread.update_token_usage(usage, cx);- })- .ok();- Task::ready(Ok(()))- }- Err(error) => Task::ready(Err(error)),- }- }-}--struct NativeAgentSessionRetry {- connection: NativeAgentConnection,- session_id: acp_v2::SessionId,-}--impl acp_thread::AgentSessionRetry for NativeAgentSessionRetry {- fn run(&self, cx: &mut App) -> Task<Result<acp_v1::PromptResponse>> {- self.connection- .run_turn(self.session_id.clone(), cx, |thread, cx| {- thread.update(cx, |thread, cx| thread.resume(cx))- })+ let cancellation = match self.acp_thread.update(cx, |thread, cx| thread.cancel(cx)) {+ Ok(cancellation) => cancellation,+ Err(error) => return Task::ready(Err(error)),+ };+ let thread = self.thread.clone();+ let acp_thread = self.acp_thread.clone();+ cx.spawn(async move |cx| {+ // Preparation is session-owned and may precede the model turn.+ cancellation.await;+ let usage = thread.update(cx, |thread, cx| {+ thread.truncate(client_user_message_id, cx)?;+ anyhow::Ok(thread.latest_token_usage())+ })?;+ acp_thread+ .update(cx, |thread, cx| thread.update_token_usage(usage, cx))+ .log_err();+ Ok(())+ })}}@@ -3608,9 +4031,14 @@ impl SubagentHandle for NativeSubagentHandle {}},);- let task = acp_thread.update(cx, |acp_thread, cx| {- acp_thread.send(vec![message.into()], cx)- });+ let task = match acp_thread.read(cx).connection().clone().into_any()+ .downcast::<NativeAgentConnection>()+ {+ Ok(connection) => connection.send_and_wait_for_completion(+ acp_thread.clone(), vec![message.into()], cx,+ ),+ Err(_) => Task::ready(Err(anyhow!("Subagent connection is not native"))),+ };(task, token_limit_rx, subscription)});@@ -3621,7 +4049,7 @@ impl SubagentHandle for NativeSubagentHandle {if thread.read_with(cx, |thread, _| thread.is_turn_complete()) {task.await} else {- thread.update(cx, |thread, cx| thread.cancel(cx)).await;+ thread.update(cx, |thread, cx| thread.request_cancel(cx)).await;Err(anyhow!("The agent is nearing the end of its context window and has been \stopped. You can prompt the thread again to have the agent wrap up \@@ -3632,16 +4060,19 @@ impl SubagentHandle for NativeSubagentHandle {};let discard_partial_output = matches!(&response,- Ok(Some(acp_thread::SubmissionResponse::LegacyCompleted(response))) if response.stop_reason == acp_v1::StopReason::Cancelled- || response.stop_reason == acp_v1::StopReason::Refusal+ Ok(acp_v2::StopReason::Cancelled | acp_v2::StopReason::Refusal));let result = match response {- Ok(Some(acp_thread::SubmissionResponse::LegacyCompleted(response))) => match response.stop_reason {- acp_v1::StopReason::Cancelled => Err(anyhow!("User canceled")),- acp_v1::StopReason::MaxTokens => Err(anyhow!("The agent reached the maximum number of tokens.")),- acp_v1::StopReason::MaxTurnRequests => Err(anyhow!("The agent reached the maximum number of allowed requests between user turns. Try prompting again.")),- acp_v1::StopReason::Refusal => Err(anyhow!("The agent refused to process that prompt. Try again.")),- _ => thread.read_with(cx, |thread, _cx| {+ Ok(reason) => match reason {+ acp_v2::StopReason::Cancelled => Err(anyhow!("User canceled")),+ acp_v2::StopReason::MaxTokens => Err(anyhow!("The agent reached the maximum number of tokens.")),+ acp_v2::StopReason::MaxTurnRequests => Err(anyhow!("The agent reached the maximum number of allowed requests between user turns. Try prompting again.")),+ acp_v2::StopReason::Refusal => Err(anyhow!("The agent refused to process that prompt. Try again.")),+ acp_v2::StopReason::Error(reason) => Err(match reason.error {+ Some(error) => anyhow::Error::new(*error),+ None => anyhow!("Native agent stopped with an error"),+ }),+ acp_v2::StopReason::EndTurn => thread.read_with(cx, |thread, _cx| {thread.last_message().and_then(|message| {@@ -3661,11 +4092,8 @@ impl SubagentHandle for NativeSubagentHandle {}).context("No response from subagent")}),+ _ => Err(anyhow!("Native subagent returned an unsupported stop reason")),},- Ok(Some(acp_thread::SubmissionResponse::Accepted(_))) => {- Err(anyhow!("Native subagent returned acceptance instead of turn completion"))- }- Ok(None) => Err(anyhow!("No response from the agent. You can try messaging again.")),Err(error) => Err(error),};@@ -3852,8 +4280,19 @@ pub fn skill_body_resolver_for_project(project.open_buffer((worktree_id, relative_path), cx)}).await?;- let content =- cx.update(|cx| buffer.read(cx).as_text_snapshot().as_rope().to_string());+ let content = cx.update(|cx| {+ // Retries can retain skills after their worktree leaves the catalog.+ if let Some(trusted_worktrees) = TrustedWorktrees::try_get_global(cx) {+ let worktree_store = project.read(cx).worktree_store();+ anyhow::ensure!(+ trusted_worktrees.update(cx, |trusted_worktrees, cx| {+ trusted_worktrees.can_trust(&worktree_store, worktree_id, cx)+ }),+ "Cannot load a skill from a restricted worktree"+ );+ }+ anyhow::Ok(buffer.read(cx).as_text_snapshot().as_rope().to_string())+ })?;read_skill_body_from_content(&skill.skill_file_path, &content).map_err(Into::into)})@@ -3981,39 +4420,6 @@ mod internal_tests {use settings::{LanguageModelProviderSetting, SettingsStore};use util::{path, rel_path::rel_path};- #[test]- fn native_stop_reasons_preserve_legacy_completions() -> Result<()> {- for (native, legacy) in [- (acp_v2::StopReason::EndTurn, acp_v1::StopReason::EndTurn),- (acp_v2::StopReason::MaxTokens, acp_v1::StopReason::MaxTokens),- (- acp_v2::StopReason::MaxTurnRequests,- acp_v1::StopReason::MaxTurnRequests,- ),- (acp_v2::StopReason::Refusal, acp_v1::StopReason::Refusal),- (acp_v2::StopReason::Cancelled, acp_v1::StopReason::Cancelled),- ] {- assert_eq!(legacy_native_completion(native)?.stop_reason, legacy);- }- assert!(- legacy_native_completion(acp_v2::StopReason::Other(acp_v2::OtherStopReason::new(- "_future",- Default::default(),- )))- .is_err(),- "an unsupported reason must not masquerade as successful completion"- );- let error = legacy_native_completion(acp_v2::ErrorStopReason::new().into())- .expect_err("an error without details is not successful completion");- assert_eq!(error.to_string(), "Native agent stopped with an error");- let details = acp_v2::Error::auth_required().data(json!({"hint": "sign in"}));- let error =- legacy_native_completion(acp_v2::ErrorStopReason::new().error(details.clone()).into())- .expect_err("reported error details propagate");- assert_eq!(error.downcast_ref::<acp_v2::Error>(), Some(&details));- Ok(())- }-#[gpui::test]fn test_available_native_agent_hides_hidden_providers(cx: &mut TestAppContext) {init_test(cx);@@ -4177,95 +4583,1326 @@ mod internal_tests {.expect("terminal should remain available while the tool call is running").read_with(cx, |terminal, _cx| terminal.inner().clone());assert!(- historical_terminal.read_with(cx, |terminal, _cx| terminal.has_active_pty_resources()),- "the full terminal tool path should create a real PTY"+ historical_terminal.read_with(cx, |terminal, _cx| terminal.has_active_pty_resources()),+ "the full terminal tool path should create a real PTY"+ );++ historical_terminal.update(cx, |terminal, _cx| terminal.input(b"\n".to_vec()));++ let result = task.await.expect("native terminal tool call succeeds");+ assert_eq!(result, "Command executed successfully.");+ assert!(+ historical_terminal.read_with(cx, |terminal, _cx| {+ terminal.is_pty() && terminal.pid_getter().is_some()+ }),+ "completed terminal history should retain PTY process metadata"+ );+ assert!(+ !historical_terminal.read_with(cx, |terminal, _cx| terminal.has_active_pty_resources()),+ "completed terminal history should not retain active PTY resources"+ );++ cx.run_until_parked();+ assert!(+ acp_thread.read_with(cx, |thread, _cx| thread.terminal(terminal_id).is_err()),+ "the full terminal tool call should release its terminal from the ACP thread"+ );+ assert!(+ !historical_terminal.read_with(cx, |terminal, _cx| terminal.has_active_pty_resources()),+ "releasing the ACP terminal should keep PTY resources released"+ );+ }++ fn make_global_skill(name: &str, description: &str) -> Skill {+ Skill {+ name: name.to_string(),+ description: description.to_string(),+ source: SkillSource::Global,+ directory_path: PathBuf::from(format!("/home/user/.agents/skills/{name}")),+ skill_file_path: PathBuf::from(format!("/home/user/.agents/skills/{name}/SKILL.md")),+ load_warnings: Vec::new(),+ disable_model_invocation: false,+ embedded_body: None,+ }+ }++ async fn setup_native_agent_session(+ cx: &mut TestAppContext,+ ) -> (+ Rc<NativeAgentConnection>,+ Entity<NativeAgent>,+ Entity<Project>,+ Entity<AcpThread>,+ ) {+ let fs = FakeFs::new(cx.executor());+ fs.insert_tree("/", json!({ "a": {} })).await;+ let project = Project::test(fs.clone(), [Path::new("/a")], cx).await;+ let thread_store = cx.new(|cx| ThreadStore::new(cx));+ let agent = cx.update(|cx| NativeAgent::new(thread_store, Templates::new(), fs, cx));+ let connection = Rc::new(NativeAgentConnection(agent.clone()));+ let acp_thread = cx+ .update(|cx| {+ connection.clone().new_session(+ project.clone(),+ PathList::new(&[Path::new("/a")]),+ cx,+ )+ })+ .await+ .unwrap();++ (connection, agent, project, acp_thread)+ }++ fn native_thread_for_session(+ agent: &Entity<NativeAgent>,+ session_id: &acp_v2::SessionId,+ cx: &App,+ ) -> Entity<Thread> {+ agent.read_with(cx, |agent, _cx| {+ agent.sessions.get(session_id).unwrap().thread.clone()+ })+ }++ fn request_texts_after_system(+ messages: &[language_model::LanguageModelRequestMessage],+ ) -> Vec<String> {+ messages+ .iter()+ .skip(1)+ .map(language_model::LanguageModelRequestMessage::string_contents)+ .collect()+ }++ #[gpui::test]+ async fn test_native_rewind_cancels_pending_preparation(cx: &mut TestAppContext) {+ let fake = init_test(cx);+ let (_connection, agent, _project, acp_thread) = setup_native_agent_session(cx).await;+ let session_id = acp_thread.read_with(cx, |thread, _| thread.session_id().clone());+ let thread = cx.update(|cx| native_thread_for_session(&agent, &session_id, cx));+ let message_id = ClientUserMessageId::new();+ let content = vec!["rewound before model startup".into()];+ let (release, preparation) = oneshot::channel::<()>();+ let completion = cx.update(|cx| {+ thread.update(cx, |thread, cx| {+ thread.set_model(fake.model("fake"), cx);+ let path_style = thread.project().read(cx).path_style(cx);+ thread+ .push_acp_user_block(message_id.clone(), content.clone(), path_style, cx)+ .expect("accepted provider message");+ });+ acp_thread.update(cx, |thread, cx| {+ thread+ .prepare_local_prompt(message_id.clone(), content.clone(), cx)+ .expect("accepted display message")+ .detach();+ thread+ .update_session_state(+ acp_v2::StateUpdate::Running(acp_v2::RunningStateUpdate::new()),+ cx,+ )+ .expect("running");+ });+ // The initial Git checkpoint can remain pending after acceptance.+ let preparation = cx.spawn(async move |_cx| {+ preparation.await.expect("release preparation");+ });+ let (sender, receiver) = oneshot::channel();+ let completion = receiver.shared();+ let (cancellation, cancelled) = oneshot::channel();+ let retry_action = Some(NativeRetryAction::Prompt(content));+ let driver = NativeAgentConnection::drive_execution(+ agent.downgrade(),+ session_id.clone(),+ thread.clone(),+ acp_thread.downgrade(),+ message_id.clone(),+ retry_action.clone(),+ preparation,+ cancelled,+ sender,+ cx,+ );+ agent.update(cx, |agent, _cx| {+ agent+ .sessions+ .get_mut(&session_id)+ .expect("session")+ .execution = Some(NativeExecution {+ _driver: driver,+ message_id: message_id.clone(),+ retry_action,+ cancellation: Some(cancellation),+ completion: completion.clone(),+ });+ });+ completion+ });+ cx.run_until_parked();+ acp_thread+ .update(cx, |thread, cx| thread.rewind(message_id.clone(), cx))+ .await+ .expect("rewind accepted message");+ if release.send(()).is_err() {+ log::debug!("Rewind already dropped pending preparation");+ }+ cx.run_until_parked();+ assert!(+ fake.pending_completions().is_empty(),+ "rewind must fence startup"+ );+ assert!(!thread.read_with(cx, |thread, _| thread.has_user_message(&message_id)));+ assert_eq!(+ completion.await.expect("settled").expect("cancelled"),+ acp_v2::StopReason::Cancelled+ );+ }++ #[gpui::test]+ async fn test_native_stop_does_not_wait_for_uncooperative_tool(cx: &mut TestAppContext) {+ use crate::tests::test_tools::DelayTool;+ use language_model::{LanguageModelToolUse, LanguageModelToolUseInput};++ let fake = init_test(cx);+ let database = cx+ .update(|cx| ThreadsDatabase::connect(cx))+ .await+ .expect("connect threads database");+ let tool_use_id: language_model::LanguageModelToolUseId = "held".into();+ let stored_result = |snapshot: &DbThread| {+ snapshot+ .messages+ .iter()+ .enumerate()+ .find_map(|(index, message)| {+ let result = message.as_agent_message()?.tool_results.get(&tool_use_id)?;+ Some((index, result.is_error, result.text_contents()))+ })+ };+ for rewind in [false, true] {+ let (connection, agent, _project, acp_thread) = setup_native_agent_session(cx).await;+ let session_id = acp_thread.read_with(cx, |thread, _| thread.session_id().clone());+ let thread = cx.update(|cx| native_thread_for_session(&agent, &session_id, cx));+ let model = fake.model("fake");+ cx.update(|cx| {+ let mut settings = agent_settings::AgentSettings::get_global(cx).clone();+ for profile in settings.profiles.values_mut() {+ profile.tools.insert(DelayTool::NAME.into(), true);+ }+ agent_settings::AgentSettings::override_global(settings, cx);+ });+ thread.update(cx, |thread, cx| {+ thread.set_model(model.clone(), cx);+ thread.add_tool(DelayTool);+ thread.set_title("Stable title".into(), cx);+ });+ let (receipt, completion) = cx.update(|cx| {+ connection.submit_native(session_id.clone(), Some(vec!["first".into()]), cx)+ });+ receipt.await.expect("first accepted");+ let first_message_id = thread+ .read_with(cx, |thread, _| thread.last_user_message_id())+ .expect("first user");+ cx.run_until_parked();+ let request = fake+ .pending_completions_for(&model)+ .pop()+ .expect("first reaches model");+ fake.send_event(+ &model,+ &request,+ LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse {+ id: tool_use_id.clone(),+ name: DelayTool::NAME.into(),+ raw_input: r#"{"ms":10000}"#.into(),+ input: LanguageModelToolUseInput::Json(json!({"ms": 10000})),+ is_input_complete: true,+ thought_signature: None,+ }),+ );+ fake.end_stream(&model, &request);+ cx.run_until_parked();+ acp_thread.read_with(cx, |thread, _| {+ assert!(+ thread.entries().iter().any(|entry| matches!(+ entry,+ acp_thread::AgentThreadEntry::ToolCall(call)+ if call.status() == acp_thread::ToolCallStatus::InProgress+ )),+ "tool must start before cancellation"+ );+ });++ cx.update(|cx| connection.cancel(&session_id, cx));+ cx.run_until_parked();+ assert_eq!(+ completion+ .now_or_never()+ .expect("Stop must not wait for the tool result")+ .expect("driver settled")+ .expect("cancelled"),+ acp_v2::StopReason::Cancelled+ );+ if rewind {+ acp_thread+ .update(cx, |thread, cx| thread.rewind(first_message_id.clone(), cx))+ .await+ .expect("rewind old owner before its result arrives");+ }++ let (receipt, completion) = cx.update(|cx| {+ connection.submit_native(session_id.clone(), Some(vec!["next".into()]), cx)+ });+ receipt+ .await+ .expect("next accepted before held tool returns");+ cx.run_until_parked();+ let request = fake+ .pending_completions_for(&model)+ .pop()+ .expect("next reaches model before held tool returns");+ fake.send_text(&model, &request, "next ");+ cx.run_until_parked();+ agent.read_with(cx, |agent, cx| {+ let session = agent.sessions.get(&session_id).expect("active session");+ assert!(+ session.can_skip_save_while_streaming(cx),+ "the successor's save key must settle before the late result"+ );+ assert!(session.pending_save.lock().is_none());+ });+ let saved_before_result = database+ .load_thread(session_id.clone())+ .await+ .expect("load thread before late result")+ .expect("persisted thread");+ assert_eq!(saved_before_result.title, "Stable title");+ assert!(saved_before_result.detailed_summary.is_none());+ let owner_index =+ stored_result(&saved_before_result).map(|(index, is_error, output)| {+ assert!(is_error);+ assert_eq!(output, "Tool canceled by user");+ index+ });+ assert_eq!(owner_index.is_some(), !rewind);+ cx.executor().advance_clock(Duration::from_secs(10));+ cx.run_until_parked();+ thread.read_with(cx, |thread, _| {+ assert!(+ thread.is_streaming_message(),+ "old cancellation cleanup must not flush the successor's partial"+ );+ let message = thread+ .last_received_or_pending_message()+ .expect("successor assistant message");+ assert!(+ message+ .as_agent_message()+ .expect("assistant message")+ .tool_results+ .is_empty(),+ "late tool results must not be inserted into the successor's native history"+ );+ });+ let persisted = database+ .load_thread(session_id.clone())+ .await+ .expect("load thread after late result")+ .expect("persisted thread");+ assert_eq!(persisted.title, saved_before_result.title);+ assert!(persisted.detailed_summary.is_none());+ assert_eq!(persisted.messages.len(), saved_before_result.messages.len());+ assert!(+ completion.clone().now_or_never().is_none(),+ "the successor must remain pending during the database check"+ );+ assert_eq!(+ stored_result(&persisted),+ owner_index.map(|index| (index, false, "Ding".to_owned())),+ "late output must be persisted only while its original owner is retained"+ );+ assert_eq!(+ fake.pending_completions_for(&model)+ .iter()+ .filter(|request| request.thread_id == Some(session_id.to_string()))+ .count(),+ 1,+ "old cancellation cleanup must not start another request"+ );+ fake.send_text(&model, &request, "response");+ fake.end_stream(&model, &request);+ assert_eq!(+ completion+ .await+ .expect("next driver settled")+ .expect("done"),+ acp_v2::StopReason::EndTurn+ );+ acp_thread.read_with(cx, |thread, cx| {+ let markdown = thread.to_markdown(cx);+ assert!(markdown.contains("next response"));+ assert!(!markdown.contains("Ding"));+ });+ }+ }++ #[gpui::test]+ async fn test_native_cancel_withdraws_pending_acceptance(cx: &mut TestAppContext) {+ let fake = init_test(cx);+ let (connection, agent, _project, acp_thread) = setup_native_agent_session(cx).await;+ let session_id = acp_thread.read_with(cx, |thread, _| thread.session_id().clone());+ let thread = cx.update(|cx| native_thread_for_session(&agent, &session_id, cx));+ let model = fake.model("fake");+ thread.update(cx, |thread, cx| thread.set_model(model.clone(), cx));++ // Match an already-signalled interrupt winning before the receipt task+ // has run, rather than cancelling a provider that has already started.+ let (submission, helper, cancellation, helper_id) = cx.update(|cx| {+ let submission = acp_thread.update(cx, |thread, cx| {+ thread.send(vec!["withdrawn receipt".into()], cx)+ });+ let helper = connection.send_and_wait_for_completion(+ acp_thread.clone(),+ vec!["withdrawn helper".into()],+ cx,+ );+ let helper_id = acp_thread.read(cx).latest_submission_id().expect("helper");+ assert_eq!(+ acp_thread.read(cx).foreground_activity(),+ acp_thread::ForegroundActivity::Idle+ );+ let cancellation = acp_thread.update(cx, |thread, cx| thread.cancel(cx));+ (submission, helper, cancellation, helper_id)+ });+ let submission_id = submission.id;+ cx.run_until_parked();+ cancellation.await;+ assert!(+ submission+ .await+ .expect("withdrawn receipt settles")+ .is_none()+ );+ assert_eq!(+ helper.await.expect("withdrawn helper settles"),+ acp_v2::StopReason::Cancelled+ );+ assert!(fake.pending_completions().is_empty());+ acp_thread.read_with(cx, |thread, _| {+ for id in [submission_id, helper_id] {+ assert!(matches!(+ thread.submission(id).expect("retained cancellation").state,+ acp_thread::SubmissionState::Cancelled+ ));+ }+ assert!(thread.entries().is_empty());+ });+ let saved = thread.read_with(cx, |thread, cx| thread.to_db(cx)).await;+ assert!(+ !saved+ .messages+ .iter()+ .any(|message| matches!(message.as_ref(), Message::User(_)))+ );++ let accepted = cx.update(|cx| {+ connection.send_and_wait_for_completion(+ acp_thread.clone(),+ vec!["accepted then cancelled".into()],+ cx,+ )+ });+ cx.run_until_parked();+ assert_eq!(fake.pending_completions_for(&model).len(), 1);+ let cancellation = acp_thread.update(cx, |thread, cx| thread.cancel(cx));+ cancellation.await;+ assert_eq!(+ accepted.await.expect("accepted execution cancelled"),+ acp_v2::StopReason::Cancelled+ );++ let later = cx.update(|cx| {+ connection.send_and_wait_for_completion(+ acp_thread.clone(),+ vec!["later prompt".into()],+ cx,+ )+ });+ cx.run_until_parked();+ let request = fake+ .pending_completions_for(&model)+ .pop()+ .expect("later submission reaches provider");+ assert!(+ request_texts_after_system(&request.messages)+ .iter()+ .all(|text| !text.contains("withdrawn"))+ );+ fake.send_text(&model, &request, "done");+ fake.end_stream(&model, &request);+ assert_eq!(+ later.await.expect("later execution completes"),+ acp_v2::StopReason::EndTurn+ );+ }++ #[gpui::test]+ async fn test_native_e2e_helper_waits_for_turn(cx: &mut TestAppContext) {+ use agent_servers::e2e_tests::send_and_wait_for_turn;++ let fake = init_test(cx);+ let (_connection, agent, _project, acp_thread) = setup_native_agent_session(cx).await;+ let session_id = acp_thread.read_with(cx, |thread, _| thread.session_id().clone());+ let thread = cx.update(|cx| native_thread_for_session(&agent, &session_id, cx));+ let model = fake.model("fake");+ thread.update(cx, |thread, cx| thread.set_model(model.clone(), cx));++ let mut completion = send_and_wait_for_turn(&acp_thread, vec!["hello".into()], cx);+ cx.run_until_parked();+ assert!(+ (&mut completion).now_or_never().is_none(),+ "acceptance must not complete the E2E helper"+ );+ let request = fake+ .pending_completions_for(&model)+ .pop()+ .expect("model request");+ fake.send_text(&model, &request, "hello from the fake model");+ fake.end_stream(&model, &request);+ completion+ .await+ .expect("reported stop completes the helper");+ acp_thread.read_with(cx, |thread, cx| {+ assert!(thread.to_markdown(cx).contains("hello from the fake model"));+ });++ let weak_thread = acp_thread.downgrade();+ drop(acp_thread);+ cx.run_until_parked();+ assert!(+ !weak_thread.is_upgradable(),+ "the helper must not retain the thread"+ );+ }++ #[gpui::test]+ async fn test_native_receipt_outlives_completion_observer(cx: &mut TestAppContext) {+ let fake = init_test(cx);+ let (connection, agent, _project, acp_thread) = setup_native_agent_session(cx).await;+ let session_id = acp_thread.read_with(cx, |thread, _| thread.session_id().clone());+ let thread = cx.update(|cx| native_thread_for_session(&agent, &session_id, cx));+ let model = fake.model("fake");+ thread.update(cx, |thread, cx| thread.set_model(model.clone(), cx));+ let content = vec!["retained prompt".into()];+ let (receipt, completion) = cx.update(|cx| {+ let (receipt, completion) =+ connection.submit_native(session_id.clone(), Some(content.clone()), cx);+ let receipt = acp_thread.update(cx, |thread, cx| {+ thread.submit_receipt(content.clone(), receipt, cx)+ });+ (receipt, completion)+ });+ let receipt = receipt.await.expect("acceptance precedes model completion");+ let Some(acp_thread::SubmissionResponse::Accepted(receipt)) = receipt else {+ panic!("native submission returns only acceptance");+ };+ thread.read_with(cx, |thread, _| {+ assert_eq!(+ thread+ .last_user_message_id()+ .expect("retained user")+ .message_id(),+ receipt.message_id+ );+ });+ acp_thread.read_with(cx, |thread, _| {+ assert!(matches!(+ thread.foreground_state(),+ acp_v2::StateUpdate::Running(_)+ ));+ });+ drop(completion);+ cx.run_until_parked();+ let request = fake+ .pending_completions_for(&model)+ .pop()+ .expect("driver remains owned");+ let invalid = acp_v2::ContentBlock::Other(acp_v2::OtherContentBlock::new(+ "_future",+ Default::default(),+ ));+ cx.update(|cx| {+ connection+ .receipt_submissions(&session_id, cx)+ .expect("native receipts")+ .prompt(vec![invalid], cx)+ })+ .await+ .expect_err("invalid follow-up must not cancel accepted work");+ fake.send_text(&model, &request, "done");+ fake.end_stream(&model, &request);+ cx.run_until_parked();+ acp_thread.read_with(cx, |thread, _| {+ assert!(+ matches!(thread.foreground_state(), acp_v2::StateUpdate::Idle(idle)+ if idle.stop_reason == Some(acp_v2::StopReason::EndTurn))+ );+ });+ }++ #[gpui::test]+ async fn test_native_follow_up_serializes_and_retry_reuses_message(cx: &mut TestAppContext) {+ let fake = init_test(cx);+ let (connection, agent, _project, acp_thread) = setup_native_agent_session(cx).await;+ let session_id = acp_thread.read_with(cx, |thread, _| thread.session_id().clone());+ let thread = cx.update(|cx| native_thread_for_session(&agent, &session_id, cx));+ let model = fake.model("fake");+ thread.update(cx, |thread, cx| thread.set_model(model.clone(), cx));+ let (first_receipt, first_completion) = cx.update(|cx| {+ connection.submit_native(session_id.clone(), Some(vec!["first".into()]), cx)+ });+ let first_receipt = first_receipt.await.expect("first accepted");+ cx.run_until_parked();+ let (second_receipt, second_completion) = cx.update(|cx| {+ connection.submit_native(session_id.clone(), Some(vec!["follow-up".into()]), cx)+ });+ let second_receipt = second_receipt+ .await+ .expect("follow-up accepted after old cleanup");+ assert_eq!(+ first_completion+ .await+ .expect("first driver completed")+ .expect("cancelled"),+ acp_v2::StopReason::Cancelled+ );+ assert!(second_completion.peek().is_none());+ cx.run_until_parked();+ cx.update(|cx| connection.cancel(&session_id, cx));+ assert_eq!(+ second_completion+ .await+ .expect("second driver completed")+ .expect("cancelled"),+ acp_v2::StopReason::Cancelled+ );+ let submissions = cx.update(|cx| {+ connection+ .receipt_submissions(&session_id, cx)+ .expect("native receipts")+ });+ let retry_receipt = cx+ .update(|cx| submissions.retry(cx))+ .await+ .expect("retry accepted");+ assert_eq!(retry_receipt.message_id, second_receipt.message_id);+ cx.run_until_parked();+ let saved = thread.read_with(cx, |thread, cx| thread.to_db(cx)).await;+ assert_eq!(+ saved+ .messages+ .iter()+ .filter_map(|message| match message.as_ref() {+ Message::User(user) => Some(user.id.message_id()),+ _ => None,+ })+ .collect::<Vec<_>>(),+ vec![first_receipt.message_id, second_receipt.message_id]+ );+ let request = fake+ .pending_completions_for(&model)+ .pop()+ .expect("retry reaches model");+ fake.send_text(&model, &request, "retried");+ fake.end_stream(&model, &request);+ cx.run_until_parked();+ acp_thread.read_with(cx, |thread, cx| {+ assert!(+ matches!(thread.foreground_state(), acp_v2::StateUpdate::Idle(idle)+ if idle.stop_reason == Some(acp_v2::StopReason::EndTurn))+ );+ assert!(thread.to_markdown(cx).contains("retried"));+ });+ }++ #[gpui::test]+ async fn test_native_compact_empty_and_repeated_markers_are_noops(cx: &mut TestAppContext) {+ let fake = init_test(cx);+ let (connection, agent, _project, acp_thread) = setup_native_agent_session(cx).await;+ let session_id = acp_thread.read_with(cx, |thread, _| thread.session_id().clone());+ let thread = cx.update(|cx| native_thread_for_session(&agent, &session_id, cx));+ thread.update(cx, |thread, cx| thread.set_model(fake.model("fake"), cx));+ for _ in 0..2 {+ let (receipt, completion) = cx.update(|cx| {+ connection.submit_native(session_id.clone(), Some(vec!["/compact".into()]), cx)+ });+ let receipt = receipt.await.expect("compact accepted");+ assert_eq!(+ completion.await.expect("driver completed").expect("noop"),+ acp_v2::StopReason::EndTurn+ );+ let saved = thread.read_with(cx, |thread, cx| thread.to_db(cx)).await;+ let Some(Message::User(marker)) = saved.messages.last().map(|message| message.as_ref())+ else {+ panic!("compact retains the accepted empty marker");+ };+ assert_eq!(marker.id.message_id(), receipt.message_id);+ assert!(marker.content.is_empty());+ assert!(fake.pending_completions().is_empty());+ }+ }++ fn setup_native_prompt_server(+ project: &Entity<Project>,+ cx: &mut TestAppContext,+ ) -> mpsc::UnboundedReceiver<oneshot::Sender<serde_json::Value>> {+ use context_server::types::{Request, requests};+ use project::project_settings::{ContextServerSettings, ProjectSettings};++ struct PromptJsonRequest;+ impl Request for PromptJsonRequest {+ type Params = context_server::types::PromptsGetParams;+ type Response = serde_json::Value;+ const METHOD: &'static str = "prompts/get";+ }+ let server_name = "native-prompts";+ cx.update(|cx| {+ let mut settings = ProjectSettings::get_global(cx).clone();+ settings.context_servers.insert(+ server_name.into(),+ ContextServerSettings::Stdio {+ enabled: true,+ remote: false,+ command: context_server::ContextServerCommand {+ path: "somebinary".into(),+ args: Vec::new(),+ env: None,+ timeout: None,+ },+ },+ );+ ProjectSettings::override_global(settings, cx);+ });+ let (requests_sender, requests_receiver) = mpsc::unbounded();+ let transport = context_server::test::create_fake_transport(server_name, cx.executor())+ .on_request::<requests::Initialize, _>(move |_params| async move {+ serde_json::from_value(json!({+ "protocolVersion": context_server::types::LATEST_PROTOCOL_VERSION,+ "serverInfo": {"name": server_name, "version": "1.0.0"},+ "capabilities": {"prompts": {}}+ }))+ .expect("initialize response")+ })+ .on_request::<requests::PromptsList, _>(|_params| async {+ context_server::types::PromptsListResponse {+ prompts: vec![context_server::types::Prompt {+ name: "prepare".into(),+ title: None,+ description: None,+ arguments: None,+ }],+ next_cursor: None,+ meta: None,+ }+ })+ .on_request::<PromptJsonRequest, _>(move |_params| {+ let requests_sender = requests_sender.clone();+ async move {+ let (response_sender, response_receiver) = oneshot::channel();+ requests_sender+ .unbounded_send(response_sender)+ .expect("prompt request");+ response_receiver.await.expect("prompt response")+ }+ });+ let server_store = project.read_with(cx, |project, _| project.context_server_store());+ server_store.update(cx, |store, cx| {+ store.start_server(+ Arc::new(context_server::ContextServer::new(+ ContextServerId(server_name.into()),+ Arc::new(transport),+ )),+ cx,+ );+ });+ cx.run_until_parked();+ requests_receiver+ }++ async fn assert_failed_native_command_context(+ command: &str,+ reload: bool,+ cx: &mut TestAppContext,+ ) {+ let fake = init_test(cx);+ let (connection, agent, project, acp_thread) = setup_native_agent_session(cx).await;+ let mut requests = setup_native_prompt_server(&project, cx);+ agent.update(cx, |agent, _| {+ agent+ .projects+ .get_mut(&project.entity_id())+ .expect("project state")+ .skills = Arc::new(vec![make_global_skill("missing-skill", "Missing skill")]);+ });+ let session_id = acp_thread.read_with(cx, |thread, _| thread.session_id().clone());+ let thread = cx.update(|cx| native_thread_for_session(&agent, &session_id, cx));+ let model = fake.model("fake");+ thread.update(cx, |thread, cx| thread.set_model(model.clone(), cx));+ let content = vec![command.into()];+ let (receipt, completion) =+ cx.update(|cx| connection.submit_native(session_id.clone(), Some(content), cx));+ let receipt = receipt.await.expect("command accepted");+ if command == "/native-prompts.prepare" {+ requests+ .next()+ .await+ .expect("fetch prompt")+ .send(json!({"malformed": true}))+ .expect("malformed response");+ }+ completion+ .await+ .expect("driver completed")+ .expect_err("command preparation fails");+ assert!(fake.pending_completions().is_empty());+ let accepted_id = thread+ .read_with(cx, |thread, _| thread.last_user_message_id())+ .expect("accepted command retained");+ assert_eq!(accepted_id.message_id(), receipt.message_id);++ let (acp_thread, thread) = if reload {+ drop(thread);+ drop(acp_thread);+ release_dropped_entities(cx);+ agent.read_with(cx, |agent, _| {+ assert!(!agent.sessions.contains_key(&session_id));+ });+ let acp_thread = agent+ .update(cx, |agent, cx| {+ agent.open_thread(session_id.clone(), project.clone(), cx)+ })+ .await+ .expect("reload failed command");+ let thread = cx.update(|cx| native_thread_for_session(&agent, &session_id, cx));+ thread.update(cx, |thread, cx| thread.set_model(model.clone(), cx));+ let (retry, completion) =+ cx.update(|cx| connection.submit_native(session_id.clone(), None, cx));+ assert_eq!(+ retry.await.expect("reloaded retry accepted").message_id,+ receipt.message_id+ );+ cx.run_until_parked();+ let request = fake+ .pending_completions_for(&model)+ .pop()+ .expect("reloaded retry resumes retained history");+ assert!(+ !request_texts_after_system(&request.messages)+ .iter()+ .any(|text| text.contains(command)),+ "reload retry must not send an unprepared command to the model"+ );+ cx.update(|cx| connection.cancel(&session_id, cx));+ completion+ .await+ .expect("retry driver completed")+ .expect("retry cancelled");+ (acp_thread, thread)+ } else {+ (acp_thread, thread)+ };+ let (receipt, completion) = cx.update(|cx| {+ connection.submit_native(+ session_id.clone(),+ Some(vec!["ordinary follow-up".into()]),+ cx,+ )+ });+ receipt.await.expect("follow-up accepted");+ cx.run_until_parked();+ let request = fake+ .pending_completions_for(&model)+ .pop()+ .expect("follow-up reaches model");+ let expected_context = if reload {+ vec!["Continue where you left off", "ordinary follow-up"]+ } else {+ vec!["ordinary follow-up"]+ };+ assert_eq!(+ request_texts_after_system(&request.messages),+ expected_context,+ "failed preparation must not contaminate a subsequent model prompt"+ );+ let saved = thread.read_with(cx, |thread, cx| thread.to_db(cx)).await;+ assert!(+ matches!(saved.messages.first().map(|message| message.as_ref()),+ Some(Message::User(marker)) if marker.id == accepted_id && marker.content.is_empty()),+ "the receipt and rewind target remain retained without unprepared provider content"+ );+ acp_thread.read_with(cx, |thread, cx| {+ assert!(thread.can_rewind_to(Some(&accepted_id), cx));+ });+ fake.send_text(&model, &request, "done");+ fake.end_stream(&model, &request);+ completion+ .await+ .expect("follow-up driver completed")+ .expect("follow-up completed");+ }++ #[gpui::test]+ async fn test_native_failed_mcp_follow_up_context(cx: &mut TestAppContext) {+ assert_failed_native_command_context("/native-prompts.prepare", false, cx).await;+ }++ #[gpui::test]+ async fn test_native_failed_mcp_reload_context(cx: &mut TestAppContext) {+ assert_failed_native_command_context("/native-prompts.prepare", true, cx).await;+ }++ #[gpui::test]+ async fn test_native_failed_skill_follow_up_context(cx: &mut TestAppContext) {+ assert_failed_native_command_context("/:missing-skill do work", false, cx).await;+ }++ #[gpui::test]+ async fn test_native_failed_skill_reload_context(cx: &mut TestAppContext) {+ assert_failed_native_command_context("/:missing-skill do work", true, cx).await;+ }++ #[gpui::test]+ async fn test_native_mcp_retry_and_display_rows_use_retained_ids(cx: &mut TestAppContext) {+ let fake = init_test(cx);+ let (connection, agent, project, acp_thread) = setup_native_agent_session(cx).await;+ let mut requests = setup_native_prompt_server(&project, cx);+ let session_id = acp_thread.read_with(cx, |thread, _| thread.session_id().clone());+ let thread = cx.update(|cx| native_thread_for_session(&agent, &session_id, cx));+ let model = fake.model("fake");+ thread.update(cx, |thread, cx| thread.set_model(model.clone(), cx));+ let (receipt, completion) = cx.update(|cx| {+ connection.submit_native(+ session_id.clone(),+ Some(vec!["/native-prompts.prepare".into()]),+ cx,+ )+ });+ let receipt = receipt.await.expect("MCP command accepted");+ requests+ .next()+ .await+ .expect("fetch prompt")+ .send(json!({"malformed": true}))+ .expect("malformed response");+ completion+ .await+ .expect("driver completed")+ .expect_err("prompt fetch response invalid");++ let server_store = project.read_with(cx, |project, _| project.context_server_store());+ server_store.update(cx, |store, cx| {+ store+ .stop_server(&ContextServerId("native-prompts".into()), cx)+ .expect("stop server");+ });+ cx.run_until_parked();+ let (retry, completion) =+ cx.update(|cx| connection.submit_native(session_id.clone(), None, cx));+ assert_eq!(+ retry.await.expect("disconnected retry accepted").message_id,+ receipt.message_id+ );+ assert!(+ completion+ .await+ .expect("driver completed")+ .expect_err("server disconnected")+ .to_string()+ .contains("Context server not found")+ );+ assert!(+ fake.pending_completions().is_empty(),+ "a missing prompt catalog must not turn retry into a literal model prompt"+ );+ requests = setup_native_prompt_server(&project, cx);+ let (retry, completion) =+ cx.update(|cx| connection.submit_native(session_id.clone(), None, cx));+ assert_eq!(+ retry.await.expect("retry accepted").message_id,+ receipt.message_id+ );+ requests+ .next()+ .await+ .expect("retry fetches prompt again")+ .send(json!({"messages": [+ {"role": "assistant", "content": {"type": "text", "text": "prepared opening"}},+ {"role": "user", "content": {"type": "text", "text": "first expanded user"}},+ {"role": "assistant", "content": {"type": "text", "text": "prepared answer"}},+ {"role": "user", "content": {"type": "text", "text": "second expanded user"}}+ ]}))+ .expect("expanded prompt response");+ cx.run_until_parked();+ let saved = thread.read_with(cx, |thread, cx| thread.to_db(cx)).await;+ let provider_ids = saved+ .messages+ .iter()+ .filter_map(|message| match message.as_ref() {+ Message::User(user) => Some(user.id.clone()),+ _ => None,+ })+ .collect::<Vec<_>>();+ assert_eq!(+ provider_ids.len(),+ 3,+ "accepted header and two expanded users"+ );+ assert_eq!(provider_ids.iter().collect::<HashSet<_>>().len(), 3);+ assert_eq!(+ provider_ids.first().expect("accepted header").message_id(),+ receipt.message_id+ );+ assert!(+ matches!(saved.messages.first().map(|message| message.as_ref()),+ Some(Message::User(header)) if header.content.is_empty())+ );+ let displayed_ids = acp_thread.read_with(cx, |thread, cx| {+ thread+ .entries()+ .iter()+ .filter_map(|entry| match entry {+ acp_thread::AgentThreadEntry::UserMessage(message) if message.indented => {+ assert!(thread.can_rewind_to(message.client_id.as_ref(), cx));+ message.client_id.clone()+ }+ _ => None,+ })+ .collect::<Vec<_>>()+ });+ assert_eq!(+ displayed_ids.as_slice(),+ provider_ids.get(1..).expect("expanded provider ids"),+ "every editable display row has its actual provider rewind target"+ );+ let request = fake+ .pending_completions_for(&model)+ .pop()+ .expect("expanded prompt reaches model");+ assert_eq!(+ request+ .messages+ .iter()+ .skip(1)+ .map(|message| (message.role, message.string_contents()))+ .collect::<Vec<_>>(),+ vec![+ (language_model::Role::Assistant, "prepared opening".into()),+ (language_model::Role::User, "first expanded user".into()),+ (language_model::Role::Assistant, "prepared answer".into()),+ (language_model::Role::User, "second expanded user".into()),+ ],+ "the empty accepted header must not reorder the assistant-first MCP expansion"+ );+ fake.send_text(&model, &request, "done");+ fake.end_stream(&model, &request);+ assert_eq!(+ completion+ .await+ .expect("driver completed")+ .expect("expanded"),+ acp_v2::StopReason::EndTurn+ );++ let (retry, completion) =+ cx.update(|cx| connection.submit_native(session_id.clone(), None, cx));+ assert_eq!(+ retry.await.expect("prepared retry accepted").message_id,+ receipt.message_id+ );+ cx.run_until_parked();+ assert!(+ requests.next().now_or_never().is_none(),+ "prepared history retry must not fetch or inject the prompt again"+ );+ let request = fake+ .pending_completions_for(&model)+ .pop()+ .expect("expanded history resumes");+ fake.send_text(&model, &request, "resumed");+ fake.end_stream(&model, &request);+ completion+ .await+ .expect("driver completed")+ .expect("resumed");+ acp_thread+ .update(cx, |thread, cx| {+ thread.rewind(+ displayed_ids.first().expect("first display row").clone(),+ cx,+ )+ })+ .await+ .expect("expanded first row remains a valid edit/regenerate rewind target");+ let rewound = thread.read_with(cx, |thread, cx| thread.to_db(cx)).await;+ assert_eq!(+ rewound.messages.len(),+ 2,+ "rewind retains the header and prior MCP assistant"+ );+ assert!(+ matches!(rewound.messages.first().map(|message| message.as_ref()),+ Some(Message::User(header)) if header.id.message_id() == receipt.message_id && header.content.is_empty())+ );+ assert_eq!(+ rewound.messages.get(1).map(|message| message.role()),+ Some(language_model::Role::Assistant));+ thread.read_with(cx, |thread, _| {+ assert!(displayed_ids.iter().all(|id| !thread.has_user_message(id)));+ });+ }- historical_terminal.update(cx, |terminal, _cx| terminal.input(b"\n".to_vec()));+ #[gpui::test]+ async fn test_native_skill_retry_prepares_once_after_body_read_failure(+ cx: &mut TestAppContext,+ ) {+ let fake = init_test(cx);+ let (connection, agent, project, acp_thread) = setup_native_agent_session(cx).await;+ cx.run_until_parked();+ let session_id = acp_thread.read_with(cx, |thread, _| thread.session_id().clone());+ let thread = cx.update(|cx| native_thread_for_session(&agent, &session_id, cx));+ let model = fake.model("fake");+ thread.update(cx, |thread, cx| thread.set_model(model.clone(), cx));+ let fs = project.read_with(cx, |project, _| project.fs().clone());+ let mut skill = make_global_skill("retry-skill", "Retry skill");+ skill.directory_path = PathBuf::from("/a/retry-skill");+ skill.skill_file_path = skill.directory_path.join("SKILL.md");+ fs.create_dir(&skill.directory_path)+ .await+ .expect("skill directory");+ agent.update(cx, |agent, _| {+ agent+ .projects+ .get_mut(&project.entity_id())+ .expect("project state")+ .skills = Arc::new(vec![skill.clone()]);+ });- let result = task.await.expect("native terminal tool call succeeds");- assert_eq!(result, "Command executed successfully.");+ let (receipt, completion) = cx.update(|cx| {+ connection.submit_native(+ session_id.clone(),+ Some(vec!["/:retry-skill do work".into()]),+ cx,+ )+ });+ let receipt = receipt.await.expect("skill accepted before body read");assert!(- historical_terminal.read_with(cx, |terminal, _cx| {- terminal.is_pty() && terminal.pid_getter().is_some()- }),- "completed terminal history should retain PTY process metadata"+ completion+ .await+ .expect("driver completed")+ .expect_err("missing body")+ .to_string()+ .contains("Failed to read skill body")+ );+ agent.update(cx, |agent, _| {+ agent+ .projects+ .get_mut(&project.entity_id())+ .expect("project state")+ .skills = Arc::new(Vec::new());+ });+ fs.write(+ &skill.skill_file_path,+ b"---\nname: retry-skill\ndescription: Retry skill\n---\n\nrestored instructions",+ )+ .await+ .expect("restore skill body");+ let (retry, completion) =+ cx.update(|cx| connection.submit_native(session_id.clone(), None, cx));+ assert_eq!(+ retry.await.expect("retry accepted").message_id,+ receipt.message_id);+ cx.run_until_parked();+ let request = fake+ .pending_completions_for(&model)+ .pop()+ .expect("prepared skill reaches model");+ let texts = request_texts_after_system(&request.messages);assert!(- !historical_terminal.read_with(cx, |terminal, _cx| terminal.has_active_pty_resources()),- "completed terminal history should not retain active PTY resources"+ texts+ .iter()+ .any(|text| text.contains("restored instructions") && text.contains("do work"))+ );+ assert!(!texts.iter().any(|text| text.contains("/:retry-skill")));+ cx.update(|cx| connection.cancel(&session_id, cx));+ assert_eq!(+ completion+ .await+ .expect("driver completed")+ .expect("cancelled"),+ acp_v2::StopReason::Cancelled);+ fs.remove_file(&skill.skill_file_path, Default::default())+ .await+ .expect("remove body after preparation");+ let (retry, completion) =+ cx.update(|cx| connection.submit_native(session_id.clone(), None, cx));+ assert_eq!(+ retry.await.expect("prepared retry accepted").message_id,+ receipt.message_id+ );cx.run_until_parked();+ let request = fake+ .pending_completions_for(&model)+ .pop()+ .expect("prepared history resumes without body read");assert!(- acp_thread.read_with(cx, |thread, _cx| thread.terminal(terminal_id).is_err()),- "the full terminal tool call should release its terminal from the ACP thread"+ request_texts_after_system(&request.messages)+ .iter()+ .any(|text| text.contains("restored instructions")));- assert!(- !historical_terminal.read_with(cx, |terminal, _cx| terminal.has_active_pty_resources()),- "releasing the ACP terminal should keep PTY resources released"+ fake.send_text(&model, &request, "done");+ fake.end_stream(&model, &request);+ assert_eq!(+ completion+ .await+ .expect("driver completed")+ .expect("resumed"),+ acp_v2::StopReason::EndTurn+ );+ let saved = thread.read_with(cx, |thread, cx| thread.to_db(cx)).await;+ assert_eq!(+ saved+ .messages+ .iter()+ .filter(|message| matches!(message.as_ref(), Message::User(_)))+ .count(),+ 1);}- fn make_global_skill(name: &str, description: &str) -> Skill {- Skill {- name: name.to_string(),- description: description.to_string(),- source: SkillSource::Global,- directory_path: PathBuf::from(format!("/home/user/.agents/skills/{name}")),- skill_file_path: PathBuf::from(format!("/home/user/.agents/skills/{name}/SKILL.md")),- load_warnings: Vec::new(),- disable_model_invocation: false,- embedded_body: None,- }- }-- async fn setup_native_agent_session(+ #[gpui::test]+ async fn test_native_compact_retry_repeats_cancelled_and_failed_compaction(cx: &mut TestAppContext,- ) -> (- Rc<NativeAgentConnection>,- Entity<NativeAgent>,- Entity<Project>,- Entity<AcpThread>,) {- let fs = FakeFs::new(cx.executor());- fs.insert_tree("/", json!({ "a": {} })).await;- let project = Project::test(fs.clone(), [Path::new("/a")], cx).await;- let thread_store = cx.new(|cx| ThreadStore::new(cx));- let agent = cx.update(|cx| NativeAgent::new(thread_store, Templates::new(), fs, cx));- let connection = Rc::new(NativeAgentConnection(agent.clone()));- let acp_thread = cx- .update(|cx| {- connection.clone().new_session(- project.clone(),- PathList::new(&[Path::new("/a")]),+ let fake = init_test(cx);+ let (connection, agent, project, acp_thread) = setup_native_agent_session(cx).await;+ let session_id = acp_thread.read_with(cx, |thread, _| thread.session_id().clone());+ let thread = cx.update(|cx| native_thread_for_session(&agent, &session_id, cx));+ let model = fake.model("fake");+ thread.update(cx, |thread, cx| {+ thread.set_model(model.clone(), cx);+ thread+ .push_acp_user_block(+ ClientUserMessageId::new(),+ vec!["old user".into()],+ project.read(cx).path_style(cx),cx,)- })- .await- .unwrap();+ .expect("old user");+ thread+ .push_acp_agent_block("old answer".into(), cx)+ .expect("old answer");+ });+ let (receipt, completion) = cx.update(|cx| {+ connection.submit_native(session_id.clone(), Some(vec!["/compact".into()]), cx)+ });+ let receipt = receipt.await.expect("compact accepted");+ cx.run_until_parked();+ let request = fake+ .pending_completions_for(&model)+ .pop()+ .expect("compaction starts");+ assert_eq!(+ request.intent,+ Some(CompletionIntent::ThreadContextSummarization)+ );+ cx.update(|cx| connection.cancel(&session_id, cx));+ assert_eq!(+ completion+ .await+ .expect("driver completed")+ .expect("cancelled"),+ acp_v2::StopReason::Cancelled+ );- (connection, agent, project, acp_thread)- }+ let (retry, completion) =+ cx.update(|cx| connection.submit_native(session_id.clone(), None, cx));+ assert_eq!(+ retry.await.expect("retry accepted").message_id,+ receipt.message_id+ );+ cx.run_until_parked();+ let request = fake+ .pending_completions_for(&model)+ .pop()+ .expect("retry compacts instead of resuming");+ assert_eq!(+ request.intent,+ Some(CompletionIntent::ThreadContextSummarization)+ );+ fake.end_stream(&model, &request);+ completion+ .await+ .expect("driver completed")+ .expect_err("empty summary");- fn native_thread_for_session(- agent: &Entity<NativeAgent>,- session_id: &acp_v2::SessionId,- cx: &App,- ) -> Entity<Thread> {- agent.read_with(cx, |agent, _cx| {- agent.sessions.get(session_id).unwrap().thread.clone()- })- }+ let (retry, completion) =+ cx.update(|cx| connection.submit_native(session_id.clone(), None, cx));+ assert_eq!(+ retry+ .await+ .expect("failed compact retry accepted")+ .message_id,+ receipt.message_id+ );+ cx.run_until_parked();+ let request = fake+ .pending_completions_for(&model)+ .pop()+ .expect("failed compact retries summary");+ assert_eq!(+ request.intent,+ Some(CompletionIntent::ThreadContextSummarization)+ );+ assert_eq!(+ request_texts_after_system(&request.messages),+ vec![+ "old user".to_string(),+ "old answer".to_string(),+ COMPACTION_PROMPT.to_string()+ ]+ );+ fake.send_text(&model, &request, "retained context");+ fake.end_stream(&model, &request);+ assert_eq!(+ completion+ .await+ .expect("driver completed")+ .expect("compacted"),+ acp_v2::StopReason::EndTurn+ );+ let saved = thread.read_with(cx, |thread, cx| thread.to_db(cx)).await;+ assert_eq!(saved.messages.iter().filter(|message| matches!(message.as_ref(), Message::User(user) if user.id.message_id() == receipt.message_id)).count(), 1);- fn request_texts_after_system(- messages: &[language_model::LanguageModelRequestMessage],- ) -> Vec<String> {- messages- .iter()- .skip(1)- .map(language_model::LanguageModelRequestMessage::string_contents)- .collect()+ let (retry, completion) =+ cx.update(|cx| connection.submit_native(session_id.clone(), None, cx));+ assert_eq!(+ retry+ .await+ .expect("completed compact retry accepted")+ .message_id,+ receipt.message_id+ );+ assert_eq!(+ completion+ .await+ .expect("driver completed")+ .expect("already compacted"),+ acp_v2::StopReason::EndTurn+ );}#[gpui::test]@@ -4275,7 +5912,7 @@ mod internal_tests {use language_model::{LanguageModelToolUse, LanguageModelToolUseInput};let fake = init_test(cx);- let (_connection, agent, project, acp_thread) = setup_native_agent_session(cx).await;+ let (connection, agent, project, acp_thread) = setup_native_agent_session(cx).await;cx.run_until_parked();let session_id = acp_thread.read_with(cx, |thread, _| thread.session_id().clone());let thread = cx.update(|cx| native_thread_for_session(&agent, &session_id, cx));@@ -4300,10 +5937,10 @@ mod internal_tests {.expect("project state").skills = Arc::new(vec![skill]);});- let send = acp_thread.update(cx, |thread, cx| {- thread.send(vec!["/:release-skill".into()], cx)+ let (receipt, completion) = cx.update(|cx| {+ connection.submit_native(session_id.clone(), Some(vec!["/:release-skill".into()]), cx)});- let send = cx.foreground_executor().spawn(send);+ receipt.await.expect("skill accepted");cx.run_until_parked();let request = fake.pending_completions_for(&model)@@ -4325,15 +5962,22 @@ mod internal_tests {fake.end_stream(&model, &request);cx.run_until_parked();assert!(acp_thread.read_with(cx, |thread, _| thread.is_waiting_for_confirmation()));+ let weak_thread = acp_thread.downgrade();drop(acp_thread);release_dropped_entities(cx);+ assert!(+ weak_thread.upgrade().is_none(),+ "command must not retain the last AcpThread owner"+ );assert!(agent.read_with(cx, |agent, _| !agent.sessions.contains_key(&session_id)));assert!(thread.read_with(cx, |thread, _| thread.is_turn_complete()),"release cancels model even with retained native Thread");- send.await- .expect_err("release cancels the pending completion");+ assert!(+ completion.await.is_err(),+ "release drops the Session-owned driver"+ );}#[gpui::test]@@ -4352,12 +5996,10 @@ mod internal_tests {assert!(connection.validate_prompt_content(&content).is_err());let error = cx.update(|cx| {- acp_thread::AgentSessionClientUserMessageIds::prompt(- connection.as_ref(),- ClientUserMessageId::new(),- acp_v2::PromptRequest::new(session_id.clone(), content),- cx,- )+ connection+ .receipt_submissions(&session_id, cx)+ .expect("native receipts")+ .prompt(content, cx)}).await.expect_err("unsupported content must not reach command dispatch or the model");@@ -4444,6 +6086,16 @@ mod internal_tests {fake.send_text(&model, &request, "done");fake.end_stream(&model, &request);send.await.expect("skill prompt should complete");+ let saved = thread.read_with(cx, |thread, cx| thread.to_db(cx)).await;+ assert_eq!(+ saved+ .messages+ .iter()+ .filter(|message| matches!(message.as_ref(), Message::User(_)))+ .count(),+ 1,+ "skill expansion must reuse the accepted provider message"+ );}#[gpui::test]@@ -4511,14 +6163,8 @@ mod internal_tests {});});- let compact_message_id = ClientUserMessageId::new();let prompt_task = cx.update(|cx| {- acp_thread::AgentSessionClientUserMessageIds::prompt(- connection.as_ref(),- compact_message_id,- acp_v2::PromptRequest::new(session_id.0.clone(), vec!["/compact".into()]),- cx,- )+ connection.send_and_wait_for_completion(acp_thread.clone(), vec!["/compact".into()], cx)});cx.run_until_parked();@@ -4544,37 +6190,26 @@ mod internal_tests {};assert!(thread.is_compacting());assert!(compaction.is_in_progress());- assert_eq!(compaction.summary.blocks().len(), 0);- assert!(compaction.summary.source_blocks().is_empty());- assert!(compaction.meta.is_none());compaction.id.clone()});fake.send_text(&model, &request, "retained ");cx.run_until_parked();- let summary = acp_thread.read_with(cx, |thread, cx| {+ acp_thread.read_with(cx, |thread, cx| {let Some(acp_thread::AgentThreadEntry::ContextCompaction(compaction)) =thread.entries().last()else {panic!("native compaction entry should remain in the timeline");};- assert_eq!(compaction.id, compaction_id);assert!(compaction.is_in_progress());assert_eq!(- compaction.summary.source_blocks(),- &[acp_v2::ContentBlock::Text(acp_v2::TextContent::new(- "retained "- ))]+ compaction+ .summary+ .blocks()+ .next()+ .map(|block| block.to_markdown(cx)),+ Some("retained "));- let blocks = compaction.summary.blocks().collect::<Vec<_>>();- let [summary] = blocks.as_slice() else {- panic!("native text chunks should create one retained Markdown block");- };- let markdown = summary- .markdown()- .expect("native text should have markdown");- assert_eq!(markdown.read(cx).source().as_ref(), "retained ");- markdown.clone()});fake.send_text(&model, &request, "context");fake.end_stream(&model, &request);@@ -4582,6 +6217,14 @@ mod internal_tests {prompt_task.await.expect("native compaction should complete");+ let saved = thread.read_with(cx, |thread, cx| thread.to_db(cx)).await;+ assert_eq!(+ saved.messages.iter().filter(+ |message| matches!(message.as_ref(), Message::User(user) if user.content.is_empty()),+ ).count(),+ 1,+ "successful compaction must not duplicate the accepted marker"+ );acp_thread.read_with(cx, |thread, cx| {let Some(acp_thread::AgentThreadEntry::ContextCompaction(compaction)) =thread.entries().last()@@ -4594,17 +6237,14 @@ mod internal_tests {compaction.status,acp_thread::ContextCompactionStatus::Completed);- assert!(compaction.error.is_none());- assert_eq!(compaction.summary.blocks().len(), 1);- assert_eq!(compaction.summary.markdowns().next(), Some(&summary));assert_eq!(- compaction.summary.source_blocks(),- &[- acp_v2::ContentBlock::Text(acp_v2::TextContent::new("retained ")),- acp_v2::ContentBlock::Text(acp_v2::TextContent::new("context")),- ]+ compaction+ .summary+ .blocks()+ .next()+ .map(|block| block.to_markdown(cx)),+ Some("retained context"));- assert_eq!(summary.read(cx).source().as_ref(), "retained context");});agent.update(cx, |agent, cx| agent.save_thread(thread.clone(), cx));@@ -4612,9 +6252,6 @@ mod internal_tests {drop(thread);drop(acp_thread);release_dropped_entities(cx);- agent.read_with(cx, |agent, _| {- assert!(!agent.sessions.contains_key(&session_id));- });let restored = cx.update(|cx| {connection.clone().load_session(@@ -4653,12 +6290,6 @@ mod internal_tests {.map(|block| block.to_markdown(cx)),Some("retained context"));- assert_eq!(- compaction.summary.source_blocks(),- &[acp_v2::ContentBlock::Text(acp_v2::TextContent::new(- "retained context"- ))]- );});}@@ -4712,10 +6343,7 @@ mod internal_tests {compaction.status,acp_thread::ContextCompactionStatus::Completed);- assert_eq!(compaction.summary.blocks().len(), 0);assert!(compaction.summary.source_blocks().is_empty());- assert!(compaction.meta.is_none());- assert!(compaction.error.is_none());assert!(!thread.is_compacting());});}@@ -4739,12 +6367,7 @@ mod internal_tests {});let first_prompt = cx.update(|cx| {- acp_thread::AgentSessionClientUserMessageIds::prompt(- connection.as_ref(),- ClientUserMessageId::new(),- acp_v2::PromptRequest::new(session_id.0.clone(), vec!["old user".into()]),- cx,- )+ connection.send_and_wait_for_completion(acp_thread.clone(), vec!["old user".into()], cx)});cx.run_until_parked();@@ -4768,12 +6391,7 @@ mod internal_tests {.expect("first user prompt should complete");let second_prompt = cx.update(|cx| {- acp_thread::AgentSessionClientUserMessageIds::prompt(- connection.as_ref(),- ClientUserMessageId::new(),- acp_v2::PromptRequest::new(session_id.0, vec!["new user".into()]),- cx,- )+ connection.send_and_wait_for_completion(acp_thread.clone(), vec!["new user".into()], cx)});cx.run_until_parked();@@ -4883,7 +6501,7 @@ mod internal_tests {Some("retained partial summary"),),] {- let (connection, agent, project, acp_thread) = setup_native_agent_session(cx).await;+ let (_connection, agent, project, acp_thread) = setup_native_agent_session(cx).await;let session_id = acp_thread.read_with(cx, |thread, _| thread.session_id().clone());let thread = cx.update(|cx| native_thread_for_session(&agent, &session_id, cx));let model = fake.model("fake");@@ -4931,27 +6549,42 @@ mod internal_tests {cx.run_until_parked();}- let cancellation_task = thread.update(cx, |thread, cx| thread.cancel(cx));+ fake.send_event(+ &model,+ &request,+ LanguageModelCompletionEvent::UsageUpdate(language_model::TokenUsage {+ input_tokens: 1234,+ ..Default::default()+ }),+ );+ let cancellation_task = thread.update(cx, |thread, cx| {+ let cancellation = thread.cancel(cx);+ thread.prepare_local_turn(cx);+ cancellation+ });(response_stream, cancellation_task)};cancellation_task.await;+ thread.read_with(cx, |thread, _| {+ assert_eq!(+ thread.cumulative_token_usage(),+ language_model::TokenUsage::default(),+ "{scenario}: queued compaction usage must not apply after cancellation"+ );+ });let response = cx.update(|cx| {NativeAgentConnection::handle_thread_events(response_stream,acp_thread.downgrade(),- Some(connection.as_ref().clone()),+ Some(agent.downgrade()),cx,)}).await.expect("canceled compaction events should be bridged");- assert_eq!(- response.stop_reason,- acp_v1::StopReason::Cancelled,- "{scenario}"- );+ assert_eq!(response, acp_v2::StopReason::Cancelled, "{scenario}");acp_thread.read_with(cx, |thread, cx| {let compactions = thread@@ -5019,10 +6652,9 @@ mod internal_tests {for tool_name in ["read_file", "unavailable_tool"] {let prompt_task = cx.update(|cx| {- acp_thread::AgentSessionClientUserMessageIds::prompt(- connection.as_ref(),- ClientUserMessageId::new(),- acp_v2::PromptRequest::new(session_id.0.clone(), vec!["use a tool".into()]),+ connection.send_and_wait_for_completion(+ acp_thread.clone(),+ vec!["use a tool".into()],cx,)});@@ -5094,9 +6726,6 @@ mod internal_tests {drop(thread);drop(acp_thread);release_dropped_entities(cx);- agent.read_with(cx, |agent, _| {- assert!(!agent.sessions.contains_key(&session_id));- });let restored = cx.update(|cx| {@@ -6655,6 +8284,23 @@ mod internal_tests {body, "edited body","resolver must read the in-memory buffer, not the on-disk file");+ cx.update(|cx| {+ use project::trusted_worktrees::PathTrust;+ TrustedWorktrees::try_get_global(cx)+ .expect("trust initialized")+ .update(cx, |trusted_worktrees, cx| {+ trusted_worktrees.restrict(+ project.read(cx).worktree_store().downgrade(),+ collections::HashSet::from_iter([PathTrust::Worktree(worktree_id)]),+ cx,+ );+ });+ });+ let error = cx+ .update(|cx| resolver(skill, &mut cx.to_async()))+ .await+ .expect_err("a retained skill cannot bypass revoked worktree trust");+ assert!(error.to_string().contains("restricted"));}/// A project SKILL.md whose on-disk size exceeds the cap must bediff --git a/crates/agent/src/tests/mod.rs b/crates/agent/src/tests/mod.rsindex e1e97e1b11e..c600d0242fc 100644--- a/crates/agent/src/tests/mod.rs+++ b/crates/agent/src/tests/mod.rs@@ -54,7 +54,7 @@ use std::{};use util::path;-mod test_tools;+pub(crate) mod test_tools;use test_tools::*;/// Returns the fake provider that serves the registry's default model.@@ -4504,12 +4504,10 @@ async fn test_agent_connection(cx: &mut TestAppContext) {release_dropped_entities(cx);let result = cx.update(|cx| {- acp_thread::AgentSessionClientUserMessageIds::prompt(- &connection,- acp_thread::ClientUserMessageId::new(),- acp_v2::PromptRequest::new(session_id.0.clone(), vec!["ghi".into()]),- cx,- )+ connection+ .receipt_submissions(&session_id, cx)+ .expect("native receipts")+ .prompt(vec!["ghi".into()], cx)}).await;assert_eq!(@@ -5849,7 +5847,9 @@ async fn test_ask_user_elicitation_references_scoped_tool_call_id(cx: &mut TestA});cx.run_until_parked();- let send = acp_thread.update(cx, |thread, cx| thread.send_raw("Prompt", cx));+ let send = cx.update(|cx| {+ connection.send_and_wait_for_completion(acp_thread.clone(), vec!["Prompt".into()], cx)+ });cx.run_until_parked();let ask_user_input = AskUserToolInput {question: "Which directory should we explore?".to_string(),@@ -6053,7 +6053,9 @@ async fn test_subagent_tool_call_end_to_end(cx: &mut TestAppContext) {});cx.run_until_parked();- let send = acp_thread.update(cx, |thread, cx| thread.send_raw("Prompt", cx));+ let send = cx.update(|cx| {+ connection.send_and_wait_for_completion(acp_thread.clone(), vec!["Prompt".into()], cx)+ });cx.run_until_parked();let request = fake.pending_completions_for(&model).pop().unwrap();fake.send_text(&model, &request, "spawning subagent");@@ -6193,7 +6195,9 @@ async fn test_subagent_tool_output_does_not_include_thinking(cx: &mut TestAppCon});cx.run_until_parked();- let send = acp_thread.update(cx, |thread, cx| thread.send_raw("Prompt", cx));+ let send = cx.update(|cx| {+ connection.send_and_wait_for_completion(acp_thread.clone(), vec!["Prompt".into()], cx)+ });cx.run_until_parked();let request = fake.pending_completions_for(&model).pop().unwrap();fake.send_text(&model, &request, "spawning subagent");@@ -6350,7 +6354,9 @@ async fn test_subagent_tool_call_cancellation_during_task_prompt(cx: &mut TestAp});cx.run_until_parked();- let send = acp_thread.update(cx, |thread, cx| thread.send_raw("Prompt", cx));+ let send = cx.update(|cx| {+ connection.send_and_wait_for_completion(acp_thread.clone(), vec!["Prompt".into()], cx)+ });cx.run_until_parked();let request = fake.pending_completions_for(&model).pop().unwrap();fake.send_text(&model, &request, "spawning subagent");@@ -6483,7 +6489,9 @@ async fn test_subagent_tool_resume_session(cx: &mut TestAppContext) {cx.run_until_parked();// === First turn: create subagent ===- let send = acp_thread.update(cx, |thread, cx| thread.send_raw("First prompt", cx));+ let send = cx.update(|cx| {+ connection.send_and_wait_for_completion(acp_thread.clone(), vec!["First prompt".into()], cx)+ });cx.run_until_parked();let request = fake.pending_completions_for(&model).pop().unwrap();fake.send_text(&model, &request, "spawning subagent");@@ -6553,7 +6561,9 @@ async fn test_subagent_tool_resume_session(cx: &mut TestAppContext) {});// === Second turn: resume subagent with session_id ===- let send2 = acp_thread.update(cx, |thread, cx| thread.send_raw("Follow up", cx));+ let send2 = cx.update(|cx| {+ connection.send_and_wait_for_completion(acp_thread.clone(), vec!["Follow up".into()], cx)+ });cx.run_until_parked();let request = fake.pending_completions_for(&model).pop().unwrap();fake.send_text(&model, &request, "resuming subagent");@@ -7389,6 +7399,33 @@ async fn test_subagent_compaction_exhausts_transient_retries(cx: &mut TestAppConassert_eq!(test.fake.pending_completions(), Vec::new());}+#[gpui::test]+async fn test_subagent_parent_cancellation_before_acceptance(cx: &mut TestAppContext) {+ let test = SubagentCompactionTest::new(cx).await;+ let send = cx.update(|cx| {+ test.handle+ .send("subagent task prompt".into(), &cx.to_async())+ });+ while test+ .parent+ .read_with(cx, |thread, cx| thread.running_subagent_ids(cx).is_empty())+ {+ assert!(cx.executor().tick(), "subagent registers with its parent");+ }+ assert!(+ test.thread+ .read_with(cx, |thread, _| thread.last_user_message_id().is_none())+ );+ test.parent.update(cx, |thread, cx| thread.cancel(cx)).await;+ cx.run_until_parked();+ assert!(+ test.fake.pending_completions().is_empty(),+ "cancelled child must not start a provider request"+ );+ assert_eq!(send.await.unwrap_err().to_string(), "User canceled");+ test.assert_stopped(cx);+}+#[gpui::test]async fn test_subagent_compaction_parent_cancellation(cx: &mut TestAppContext) {let test = SubagentCompactionTest::new(cx).await;@@ -7486,7 +7523,9 @@ async fn test_subagent_error_propagation(cx: &mut TestAppContext) {cx.run_until_parked();// Start the parent turn- let send = acp_thread.update(cx, |thread, cx| thread.send_raw("Prompt", cx));+ let send = cx.update(|cx| {+ connection.send_and_wait_for_completion(acp_thread.clone(), vec!["Prompt".into()], cx)+ });cx.run_until_parked();let request = fake.pending_completions_for(&model).pop().unwrap();fake.send_text(&model, &request, "spawning subagent");diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rsindex 777933dbc01..83f64a86e29 100644--- a/crates/agent/src/thread.rs+++ b/crates/agent/src/thread.rs@@ -1274,6 +1274,7 @@ impl From<&ThreadModel> for Option<DbLanguageModel> {#[derive(PartialEq)]pub(crate) struct StreamingSaveKey {message_count: usize,+ retained_history_revision: usize,title: Option<SharedString>,summary: Option<SharedString>,model: Option<DbLanguageModel>,@@ -1295,6 +1296,8 @@ pub struct Thread {pending_summary_generation: Option<Shared<Task<Option<SharedString>>>>,summary: Option<SharedString>,messages: Vec<Arc<Message>>,+ // Message count cannot detect replacements in frozen history while a successor streams.+ retained_history_revision: usize,user_store: Entity<UserStore>,/// Holds the task that handles agent interaction until the end of the turn./// Survives across multiple requests as the model performs tool calls and@@ -1452,6 +1455,7 @@ impl Thread {pending_summary_generation: None,summary: None,messages: Vec::new(),+ retained_history_revision: 0,user_store: project.read(cx).user_store(),running_turn: None,end_turn_at_next_boundary: false,@@ -1827,6 +1831,7 @@ impl Thread {pending_summary_generation: None,summary: db_thread.detailed_summary,messages: db_thread.messages,+ retained_history_revision: 0,user_store: project.read(cx).user_store(),running_turn: None,end_turn_at_next_boundary: false,@@ -1979,6 +1984,7 @@ impl Thread {pub(crate) fn streaming_save_key(&self) -> StreamingSaveKey {StreamingSaveKey {message_count: self.messages.len(),+ retained_history_revision: self.retained_history_revision,title: self.title.clone(),summary: self.summary.clone(),model: (&self.model).into(),@@ -2356,7 +2362,9 @@ impl Thread {pub fn cancel(&mut self, cx: &mut Context<Self>) -> Task<()> {for subagent in self.running_subagents.drain(..) {if let Some(subagent) = subagent.upgrade() {- subagent.update(cx, |thread, cx| thread.cancel(cx)).detach();+ subagent+ .update(cx, |thread, cx| thread.request_cancel(cx))+ .detach();}}@@ -2365,17 +2373,26 @@ impl Thread {return Task::ready(());};+ let prompt_id = running_turn.prompt_id.clone();let turn_task = running_turn.cancel();cx.spawn(async move |this, cx| {turn_task.await;this.update(cx, |this, cx| {- this.flush_pending_message(cx);+ if this.prompt_id == prompt_id {+ this.flush_pending_message(cx);+ }}).ok();})}+ pub(crate) fn request_cancel(&mut self, cx: &mut Context<Self>) -> Task<()> {+ // A native session can own work before there is a model turn to cancel.+ cx.emit(CancellationRequested);+ self.cancel(cx)+ }+pub fn set_end_turn_at_next_boundary(&mut self, end_at_boundary: bool) {self.end_turn_at_next_boundary = end_at_boundary;}@@ -2462,6 +2479,7 @@ impl Thread {cx: &mut Context<Self>,) -> Result<()> {self.cancel(cx).detach();+ self.advance_prompt_id();// Clear pending message since cancel will try to flush it asynchronously,// and we don't want that content to be added after we truncateself.pending_message.take();@@ -2584,6 +2602,7 @@ impl Thread {&mut self,cx: &mut Context<Self>,) -> Result<mpsc::UnboundedReceiver<Result<ThreadEvent>>> {+ self.advance_prompt_id();self.messages.push(Arc::new(Message::Resume));cx.notify();@@ -2606,13 +2625,44 @@ impl Thread {let content = content.into_iter().map(Into::into).collect::<Arc<_>>();log::debug!("Thread::send content: {:?}", content);- self.messages- .push(Arc::new(Message::User(UserMessage { id, content })));- cx.notify();+ self.upsert_user_message(id, content, cx);self.send_existing(cx)}+ pub(crate) fn upsert_user_message(+ &mut self,+ id: ClientUserMessageId,+ content: Arc<[UserMessageContent]>,+ cx: &mut Context<Self>,+ ) {+ let message = Arc::new(Message::User(UserMessage {+ id: id.clone(),+ content,+ }));+ if let Some(existing) = self+ .messages+ .iter_mut()+ .find(|message| matches!(message.as_ref(), Message::User(user) if user.id == id))+ {+ *existing = message;+ self.retained_history_revision += 1;+ } else {+ self.messages.push(message);+ }+ cx.notify();+ }++ pub(crate) fn last_user_message_id(&self) -> Option<ClientUserMessageId> {+ self.last_user_message().map(|message| message.id.clone())+ }++ pub(crate) fn has_user_message(&self, id: &ClientUserMessageId) -> bool {+ self.messages+ .iter()+ .any(|message| matches!(message.as_ref(), Message::User(user) if &user.id == id))+ }+pub fn send_existing(&mut self,cx: &mut Context<Self>,@@ -2645,7 +2695,23 @@ impl Thread {self.flush_pending_message(cx);self.cancel(cx).detach();- let compaction = self.forced_compaction_target_ix().map(|request_end_ix| {+ let accepted_marker_index = self.messages.iter().position(+ |message| matches!(message.as_ref(), Message::User(user) if user.id == id && user.content.is_empty()),+ );+ let request_end_index = accepted_marker_index.unwrap_or(self.messages.len());+ let target = if accepted_marker_index.is_some_and(|index| {+ matches!(+ self.messages.get(index + 1).map(|message| message.as_ref()),+ Some(Message::Compaction(_))+ )+ }) {+ None+ } else if accepted_marker_index.is_some() {+ self.forced_compaction_target_ix_before(request_end_index)+ } else {+ self.forced_compaction_target_ix()+ };+ let compaction = target.map(|request_end_ix| {self.advance_prompt_id();let request = self.build_compaction_request(request_end_ix, &model, cx);self.current_request_token_usage = TokenUsage::default();@@ -2664,6 +2730,7 @@ impl Thread {let event_stream = ThreadEventStream::new(events_tx);let (cancellation_tx, mut cancellation_rx) = watch::channel(false);let task = cx.spawn({+ let prompt_id = self.prompt_id.clone();let event_stream = event_stream.clone();async move |this, cx| {let result = if let Some((model, request)) = compaction {@@ -2685,7 +2752,9 @@ impl Thread {// (possibly for a new turn), so leave it alone.if *cancellation_rx.borrow() {this.update(cx, |this, _| {- this.emit_compaction_telemetry_outcome("canceled", None)+ if this.prompt_id == prompt_id {+ this.emit_compaction_telemetry_outcome("canceled", None);+ }}).log_err();return;@@ -2713,6 +2782,7 @@ impl Thread {}});self.running_turn = Some(RunningTurn::new(+ self.prompt_id.clone(),event_stream,BTreeMap::default(),cancellation_tx,@@ -2722,6 +2792,13 @@ impl Thread {Ok(events_rx)}+ pub(crate) fn prepare_local_turn(&mut self, cx: &mut Context<Self>) {+ // Freeze the old partial before inserting a successor's user message,+ // and fence detached cleanup while its checkpoint or command is prepared.+ self.flush_pending_message(cx);+ self.advance_prompt_id();+ }+pub fn push_acp_user_block(&mut self,id: ClientUserMessageId,@@ -2733,9 +2810,7 @@ impl Thread {.into_iter().map(|block| UserMessageContent::from_content_block(block, path_style)).collect::<Result<Arc<_>>>()?;- self.messages- .push(Arc::new(Message::User(UserMessage { id, content })));- cx.notify();+ self.upsert_user_message(id, content, cx);Ok(())}@@ -2782,13 +2857,21 @@ impl Thread {let tools = self.enabled_tools(cx);let (cancellation_tx, mut cancellation_rx) = watch::channel(false);let task = cx.spawn({+ let prompt_id = self.prompt_id.clone();+ let user_message_id = self.last_user_message_id();let event_stream = event_stream.clone();async move |this, cx| {log::debug!("Starting agent turn execution");- let turn_result =- Self::run_turn_internal(&this, &event_stream, cancellation_rx.clone(), cx)- .await;+ let turn_result = Self::run_turn_internal(+ &this,+ &event_stream,+ &prompt_id,+ user_message_id.as_ref(),+ cancellation_rx.clone(),+ cx,+ )+ .await;// Check if we were cancelled - if so, cancel() already took running_turn// and we shouldn't touch it (it might be a NEW turn now)@@ -2825,13 +2908,21 @@ impl Thread {_ = this.update(cx, |this, _| this.running_turn.take());}});- self.running_turn = Some(RunningTurn::new(event_stream, tools, cancellation_tx, task));+ self.running_turn = Some(RunningTurn::new(+ self.prompt_id.clone(),+ event_stream,+ tools,+ cancellation_tx,+ task,+ ));Ok(events_rx)}async fn run_turn_internal(this: &WeakEntity<Self>,event_stream: &ThreadEventStream,+ prompt_id: &PromptId,+ user_message_id: Option<&ClientUserMessageId>,mut cancellation_rx: watch::Receiver<bool>,cx: &mut AsyncApp,) -> Result<()> {@@ -2840,6 +2931,9 @@ impl Thread {// Set when a refusal fallback occurs so subsequent iterations use the fallback model.let mut refusal_fallback_model: Option<LanguageModel> = None;loop {+ if *cancellation_rx.borrow() {+ return Ok(());+ }match Self::perform_compaction_if_needed(this,event_stream,@@ -2855,7 +2949,9 @@ impl Thread {Ok(ControlFlow::Continue(())) => {}Ok(ControlFlow::Break(())) => {this.update(cx, |this, _| {- this.emit_compaction_telemetry_outcome("canceled", None)+ if &this.prompt_id == prompt_id {+ this.emit_compaction_telemetry_outcome("canceled", None);+ }})?;return Ok(());}@@ -2877,7 +2973,11 @@ impl Thread {{Ok(ControlFlow::Break(())) => {this.update(cx, |this, _| {- this.emit_compaction_telemetry_outcome("canceled", None)+ if &this.prompt_id == prompt_id {+ this.emit_compaction_telemetry_outcome(+ "canceled", None,+ );+ }})?;return Ok(());}@@ -2917,6 +3017,9 @@ impl Thread {}}+ if *cancellation_rx.borrow() {+ return Ok(());+ }// Re-read the model and refresh tools on each iteration so that// mid-turn changes (e.g. the user switches model, toggles tools,// or changes profile) take effect between tool-call rounds.@@ -2962,7 +3065,14 @@ impl Thread {let mut had_refusal = false;loop {// Race between getting the first event, tool completion, and cancellation.- let first_event = futures::select! {+ let first_event = futures::select_biased! {+ _ = cancellation_rx.changed().fuse() => {+ if *cancellation_rx.borrow() {+ cancelled = true;+ break;+ }+ continue;+ }event = events.next().fuse() => event,tool_result = futures::StreamExt::select_next_some(&mut tool_results) => {let (owning_message_ix, tool_result) = tool_result;@@ -2988,13 +3098,6 @@ impl Thread {}continue;}- _ = cancellation_rx.changed().fuse() => {- if *cancellation_rx.borrow() {- cancelled = true;- break;- }- continue;- }};let Some(first_event) = first_event else {break;@@ -3066,6 +3169,9 @@ impl Thread {// This prevents deadlock when the LLM stream ends (e.g. because of an error)// before sending a tool use with `is_input_complete: true`.this.update(cx, |this, _cx| {+ if &this.prompt_id != prompt_id {+ return;+ }if let Some(running_turn) = this.running_turn.as_mut() {if running_turn.streaming_tool_inputs.is_empty() {return;@@ -3133,20 +3239,38 @@ impl Thread {let end_turn = tool_results.is_empty() && early_tool_results.is_empty();for (owning_message_ix, tool_result) in early_tool_results {- Self::process_tool_result(this, event_stream, cx, owning_message_ix, tool_result)?;+ Self::process_tool_result(+ this,+ event_stream,+ prompt_id,+ user_message_id,+ cx,+ owning_message_ix,+ tool_result,+ )?;}while let Some((owning_message_ix, tool_result)) = tool_results.next().await {- Self::process_tool_result(this, event_stream, cx, owning_message_ix, tool_result)?;+ Self::process_tool_result(+ this,+ event_stream,+ prompt_id,+ user_message_id,+ cx,+ owning_message_ix,+ tool_result,+ )?;}this.update(cx, |this, cx| {- this.flush_pending_message(cx);- if this.title.is_none() {- this.generate_title(cx);+ if &this.prompt_id == prompt_id {+ this.flush_pending_message(cx);+ if this.title.is_none() {+ this.generate_title(cx);+ }}})?;- if cancelled {+ if cancelled || *cancellation_rx.borrow() {log::debug!("Turn cancelled by user, exiting");return Ok(());}@@ -3166,6 +3290,9 @@ impl Thread {ControlFlow::Break(_) => return Ok(()),ControlFlow::Continue(_) => {}}+ if *cancellation_rx.borrow() {+ return Ok(());+ }this.update(cx, |this, _cx| {if let Some(Message::Agent(message)) = this.last_message() {if message.tool_results.is_empty() {@@ -3276,8 +3403,7 @@ impl Thread {let result: Result<ControlFlow<()>> = async {let provider =cx.update(|cx| LanguageModelRegistry::read_global(cx).provider_for_model(&model))?;- let stream = futures::select! {- result = provider.stream_completion(&model, request, cx).fuse() => result,+ let stream = futures::select_biased! {_ = cancellation_rx.changed().fuse() => {if *cancellation_rx.borrow() {log::debug!("Compaction cancelled before request started");@@ -3285,13 +3411,13 @@ impl Thread {}return Ok(ControlFlow::Continue(()));}+ result = provider.stream_completion(&model, request, cx).fuse() => result,};let mut stream = stream?;let mut summary = String::new();loop {- let event = futures::select! {- event = stream.next().fuse() => event,+ let event = futures::select_biased! {_ = cancellation_rx.changed().fuse() => {if *cancellation_rx.borrow() {log::debug!("Compaction cancelled while summarizing");@@ -3299,8 +3425,12 @@ impl Thread {}continue;}+ event = stream.next().fuse() => event,};+ if *cancellation_rx.borrow() {+ return Ok(ControlFlow::Break(()));+ }let Some(event) = event else {break;};@@ -3357,10 +3487,7 @@ impl Thread {}}CompactionInsertion::Manual { marker_id } => {- this.messages.push(Arc::new(Message::User(UserMessage {- id: marker_id,- content: Arc::from([]),- })));+ this.upsert_user_message(marker_id, Arc::from([]), cx);this.messages.push(compaction);}}@@ -3383,6 +3510,8 @@ impl Thread {fn process_tool_result(this: &WeakEntity<Thread>,event_stream: &ThreadEventStream,+ prompt_id: &PromptId,+ user_message_id: Option<&ClientUserMessageId>,cx: &mut AsyncApp,owning_message_ix: usize,tool_result: LanguageModelToolResult,@@ -3404,10 +3533,48 @@ impl Thread {}},);- this.update(cx, |this, _cx| {- this.pending_message()+ this.update(cx, |this, cx| {+ // A cancelled turn can finish its tools after a successor has started.+ if &this.prompt_id == prompt_id {+ this.pending_message()+ .tool_results+ .insert(tool_result.tool_use_id.clone(), tool_result);+ return;+ }+ let Some(user_message_id) = user_message_id else {+ return;+ };+ let owning_user_message = this.messages.iter().take(owning_message_ix).rev().find_map(+ |message| match message.as_ref() {+ Message::User(user) => Some(&user.id),+ _ => None,+ },+ );+ if owning_user_message != Some(user_message_id) {+ return;+ }+ let Some(message) = this.messages.get_mut(owning_message_ix) else {+ return;+ };+ let Some(agent_message) = message.as_agent_message() else {+ return;+ };+ if !agent_message.content.iter().any(|content| {+ matches!(content, AgentMessageContent::ToolUse(tool_use)+ if tool_use.id == tool_result.tool_use_id)+ }) {+ return;+ }+ // Keep late terminal output on its frozen owner, never on a reused+ // message index after rewind or on the successor's pending message.+ let mut agent_message = agent_message.clone();+ agent_message.tool_results- .insert(tool_result.tool_use_id.clone(), tool_result)+ .insert(tool_result.tool_use_id.clone(), tool_result);+ *message = Arc::new(Message::Agent(agent_message));+ this.retained_history_revision += 1;+ this.clear_summary();+ cx.notify();})?;Ok(())}@@ -4585,13 +4752,28 @@ impl Thread {/// Insertion point for a manually-triggered compaction./// Returns `None` only when there is nothing to summarize (no messages, or the thread already ends in a compaction).fn forced_compaction_target_ix(&self) -> Option<usize> {+ self.forced_compaction_target_ix_before(self.messages.len())+ }++ fn forced_compaction_target_ix_before(&self, mut end_index: usize) -> Option<usize> {+ while end_index > 0+ && matches!(+ self.messages.get(end_index - 1).map(|message| message.as_ref()),+ Some(Message::User(user)) if user.content.is_empty()+ )+ {+ end_index -= 1;+ }if matches!(- self.messages.last().map(|message| &**message),+ end_index+ .checked_sub(1)+ .and_then(|index| self.messages.get(index))+ .map(|message| &**message),None | Some(Message::Compaction(_))) {return None;}- Some(self.messages.len())+ Some(end_index)}fn compaction_model(&self, cx: &App) -> Option<LanguageModel> {@@ -4906,6 +5088,7 @@ enum CompactionInsertion {}struct RunningTurn {+ prompt_id: PromptId,/// 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.@@ -4926,12 +5109,14 @@ struct RunningTurn {impl RunningTurn {fn new(+ prompt_id: PromptId,event_stream: ThreadEventStream,tools: BTreeMap<SharedString, Arc<dyn AnyAgentTool>>,cancellation_tx: watch::Sender<bool>,task: Task<()>,) -> Self {Self {+ prompt_id,_task: task,event_stream,tools,@@ -5080,6 +5265,10 @@ pub struct TokenUsageUpdated(pub Option<acp_thread::TokenUsage>);impl EventEmitter<TokenUsageUpdated> for Thread {}+pub(crate) struct CancellationRequested;++impl EventEmitter<CancellationRequested> for Thread {}+pub struct TitleUpdated;impl EventEmitter<TitleUpdated> for Thread {}diff --git a/crates/agent_servers/src/e2e_tests.rs b/crates/agent_servers/src/e2e_tests.rsindex f3e5ed32f56..a03524a3d77 100644--- a/crates/agent_servers/src/e2e_tests.rs+++ b/crates/agent_servers/src/e2e_tests.rs@@ -1,10 +1,14 @@use crate::{AgentServer, AgentServerDelegate};-use acp_thread::{AcpThread, AgentThreadEntry, ToolCallStatus};+use acp_thread::{+ AcpThread, AcpThreadEvent, AgentThreadEntry, ForegroundActivity, SubmissionResponse,+ ToolCallStatus,+};use agent_client_protocol::schema::v2 as acp_v2;+use anyhow::{Context as _, Result, anyhow};use client::RefreshLlmTokenListener;-use futures::{FutureExt, StreamExt, channel::mpsc, select};+use futures::{FutureExt, StreamExt, channel::mpsc, channel::oneshot, select};use gpui::AppContext;-use gpui::{Entity, TestAppContext};+use gpui::{Entity, Task, TestAppContext};use indoc::indoc;use project::{FakeFs, Project};#[cfg(test)]@@ -26,8 +30,7 @@ wherelet project = Project::test(fs.clone(), [], cx).await;let thread = new_test_thread(server(&fs, cx).await, project.clone(), "/private/tmp", cx).await;- thread- .update(cx, |thread, cx| thread.send_raw("Hello from Zed!", cx))+ send_and_wait_for_turn(&thread, vec!["Hello from Zed!".into()], cx).await.unwrap();@@ -67,21 +70,17 @@ where.expect("failed to write file");let project = Project::example([tempdir.path()], &mut cx.to_async()).await;let thread = new_test_thread(server(&fs, cx).await, project.clone(), tempdir.path(), cx).await;- thread- .update(cx, |thread, cx| {- thread.send(- vec![- "Read the file ".into(),- acp_v2::ContentBlock::ResourceLink(acp_v2::ResourceLink::new(- "foo.rs", "foo.rs",- )),- " and tell me what the content of the println! is".into(),- ],- cx,- )- })- .await- .unwrap();+ send_and_wait_for_turn(+ &thread,+ vec![+ "Read the file ".into(),+ acp_v2::ContentBlock::ResourceLink(acp_v2::ResourceLink::new("foo.rs", "foo.rs")),+ " and tell me what the content of the println! is".into(),+ ],+ cx,+ )+ .await+ .unwrap();thread.read_with(cx, |thread, cx| {assert!(matches!(@@ -122,15 +121,13 @@ wherelet project = Project::example([tempdir.path()], &mut cx.to_async()).await;let thread = new_test_thread(server(&fs, cx).await, project.clone(), "/private/tmp", cx).await;- thread- .update(cx, |thread, cx| {- thread.send_raw(- &format!("Read {} and tell me what you see.", foo_path.display()),- cx,- )- })- .await- .unwrap();+ send_and_wait_for_turn(+ &thread,+ vec![format!("Read {} and tell me what you see.", foo_path.display()).into()],+ cx,+ )+ .await+ .unwrap();thread.read_with(cx, |thread, _cx| {assert!(thread.entries().iter().any(|entry| {matches!(@@ -162,12 +159,11 @@ pub async fn test_tool_call_with_permission<T, F>(let fs = init_test(cx).await as Arc<dyn fs::Fs>;let project = Project::test(fs.clone(), [path!("/private/tmp").as_ref()], cx).await;let thread = new_test_thread(server(&fs, cx).await, project.clone(), "/private/tmp", cx).await;- let full_turn = thread.update(cx, |thread, cx| {- thread.send_raw(- r#"Run exactly `touch hello.txt && echo "Hello, world!" | tee hello.txt` in the terminal."#,- cx,- )- });+ let full_turn = send_and_wait_for_turn(+ &thread,+ vec![r#"Run exactly `touch hello.txt && echo "Hello, world!" | tee hello.txt` in the terminal."#.into()],+ cx,+ );run_until_first_tool_call(&thread,@@ -251,12 +247,11 @@ wherelet project = Project::test(fs.clone(), [path!("/private/tmp").as_ref()], cx).await;let thread = new_test_thread(server(&fs, cx).await, project.clone(), "/private/tmp", cx).await;- let _ = thread.update(cx, |thread, cx| {- thread.send_raw(- r#"Run exactly `touch hello.txt && echo "Hello, world!" | tee hello.txt` in the terminal."#,- cx,- )- });+ let full_turn = send_and_wait_for_turn(+ &thread,+ vec![r#"Run exactly `touch hello.txt && echo "Hello, world!" | tee hello.txt` in the terminal."#.into()],+ cx,+ );let first_tool_call_ix = run_until_first_tool_call(&thread,@@ -283,6 +278,7 @@ where});thread.update(cx, |thread, cx| thread.cancel(cx)).await;+ full_turn.await.unwrap();thread.read_with(cx, |thread, _cx| {let AgentThreadEntry::ToolCall(tool_call) = &thread.entries()[first_tool_call_ix] else {panic!();@@ -290,12 +286,13 @@ whereassert_eq!(tool_call.status(), ToolCallStatus::Canceled);});- thread- .update(cx, |thread, cx| {- thread.send_raw(r#"Stop running and say goodbye to me."#, cx)- })- .await- .unwrap();+ send_and_wait_for_turn(+ &thread,+ vec!["Stop running and say goodbye to me.".into()],+ cx,+ )+ .await+ .unwrap();thread.read_with(cx, |thread, _| {assert!(matches!(&thread.entries().last().unwrap(),@@ -313,8 +310,7 @@ wherelet project = Project::test(fs.clone(), [], cx).await;let thread = new_test_thread(server(&fs, cx).await, project.clone(), "/private/tmp", cx).await;- thread- .update(cx, |thread, cx| thread.send_raw("Hello from test!", cx))+ send_and_wait_for_turn(&thread, vec!["Hello from test!".into()], cx).await.unwrap();@@ -382,6 +378,59 @@ pub use common_e2e_tests;// Helpers+pub fn send_and_wait_for_turn(+ thread: &Entity<AcpThread>,+ content: Vec<acp_v2::ContentBlock>,+ cx: &mut TestAppContext,+) -> Task<Result<()>> {+ cx.update(|cx| {+ // These tests send sequential turns; otherwise a predecessor's stop could win this wait.+ if thread.read(cx).foreground_activity() != ForegroundActivity::Idle+ || thread.read(cx).has_unsettled_submissions()+ {+ return Task::ready(Err(anyhow!(+ "send_and_wait_for_turn requires an idle thread with no unsettled submissions"+ )));+ }+ let generation = thread.read(cx).activity_generation();+ let (sender, receiver) = oneshot::channel();+ let mut sender = Some(sender);+ // Native acceptance can precede completion, and completion can precede polling the receipt.+ let subscription = cx.subscribe(thread, move |_, event, _| {+ if let AcpThreadEvent::Stopped {+ activity_generation,+ stop_reason,+ ..+ } = event+ && *activity_generation > generation+ && let Some(sender) = sender.take()+ {+ let result = match stop_reason {+ Some(acp_v2::StopReason::Error(reason)) => Err(match &reason.error {+ Some(error) => anyhow::Error::new((**error).clone()),+ None => anyhow!("Agent stopped with an error"),+ }),+ _ => Ok(()),+ };+ if sender.send(result).is_err() {+ log::debug!("Turn completion waiter was dropped");+ }+ }+ });+ let submission = thread.update(cx, |thread, cx| thread.send(content, cx));+ cx.spawn(async move |_| {+ let result = match submission.await? {+ Some(SubmissionResponse::Accepted(_)) => receiver+ .await+ .context("Thread dropped before the turn stopped")?,+ Some(SubmissionResponse::LegacyCompleted(_)) | None => Ok(()),+ };+ drop(subscription);+ result+ })+ })+}+pub async fn init_test(cx: &mut TestAppContext) -> Arc<FakeFs> {env_logger::try_init().ok();@@ -477,3 +526,91 @@ pub fn get_zed_path() -> PathBuf {zed_path}++#[cfg(test)]+mod tests {+ use super::*;+ use acp_thread::{AgentConnection, StubAgentConnection};+ use agent_client_protocol::schema::v1 as acp_v1;+ use std::rc::Rc;++ async fn stub_thread(+ receipt_submissions: bool,+ cx: &mut TestAppContext,+ ) -> (Rc<StubAgentConnection>, Entity<AcpThread>) {+ cx.update(|cx| {+ let settings_store = settings::SettingsStore::test(cx);+ cx.set_global(settings_store);+ });+ let project = Project::test(FakeFs::new(cx.executor()), [], cx).await;+ let connection =+ Rc::new(StubAgentConnection::new().with_receipt_submissions(receipt_submissions));+ let thread = cx+ .update(|cx| {+ connection.clone().new_session(+ project,+ PathList::new(&[Path::new("/private/tmp")]),+ cx,+ )+ })+ .await+ .expect("stub session");+ (connection, thread)+ }++ #[gpui::test]+ async fn test_e2e_helper_preserves_v1_completion(cx: &mut TestAppContext) {+ let (connection, thread) = stub_thread(false, cx).await;+ let response = connection.defer_next_prompt_response();+ let mut completion = send_and_wait_for_turn(&thread, vec!["hello".into()], cx);+ cx.run_until_parked();+ assert!((&mut completion).now_or_never().is_none());+ response+ .send(Ok(acp_v1::PromptResponse::new(acp_v1::StopReason::EndTurn)))+ .expect("prompt response");+ completion.await.expect("v1 completion");+ }++ #[gpui::test]+ async fn test_e2e_helper_preserves_stop_before_receipt(cx: &mut TestAppContext) {+ let (connection, thread) = stub_thread(true, cx).await;+ let receipt = connection.defer_next_receipt_response();+ let completion = send_and_wait_for_turn(&thread, vec!["fail".into()], cx);+ send_and_wait_for_turn(&thread, vec!["overlapping".into()], cx)+ .await+ .expect_err("an unsettled receipt must reject overlapping prompts");+ thread.update(cx, |thread, cx| {+ cx.emit(AcpThreadEvent::Stopped {+ activity_generation: thread.activity_generation(),+ activity_duration: None,+ stop_reason: Some(acp_v2::StopReason::EndTurn),+ });+ thread+ .update_session_state(+ acp_v2::StateUpdate::Running(acp_v2::RunningStateUpdate::new()),+ cx,+ )+ .expect("running");+ thread+ .update_session_state(+ acp_v2::StateUpdate::Idle(+ acp_v2::IdleStateUpdate::new()+ .stop_reason(acp_v2::StopReason::Error(acp_v2::ErrorStopReason::new())),+ ),+ cx,+ )+ .expect("stopped");+ });+ cx.run_until_parked();+ receipt+ .send(Ok(acp_v2::PromptResponse::new("accepted")))+ .expect("receipt");+ assert_eq!(+ completion+ .await+ .expect_err("error without details")+ .to_string(),+ "Agent stopped with an error"+ );+ }+}diff --git a/crates/eval_cli/src/main.rs b/crates/eval_cli/src/main.rsindex 13aa43ea24e..52c1547da17 100644--- a/crates/eval_cli/src/main.rs+++ b/crates/eval_cli/src/main.rs@@ -41,7 +41,7 @@ use std::time::{Duration, Instant};use acp_thread::AgentConnection as _;use agent::{NativeAgent, NativeAgentConnection, Templates, ThreadStore};-use agent_client_protocol::schema::{v1 as acp, v2 as acp_v2};+use agent_client_protocol::schema::v2 as acp_v2;use anyhow::{Context, Result};use clap::Parser;use feature_flags::FeatureFlagAppExt as _;@@ -819,9 +819,8 @@ async fn run_agent(instruction.to_string(),))];- let send_future = acp_thread.update(cx, |acp_thread: &mut acp_thread::AcpThread, cx| {- acp_thread.send(message, cx)- });+ let send_future =+ cx.update(|cx| connection.send_and_wait_for_completion(acp_thread.clone(), message, cx));let timeout_future = if let Some(timeout_secs) = timeout {futures::future::Either::Left(@@ -843,21 +842,19 @@ async fn run_agent(let outcome = select_biased! {result = send_future.fuse() => match result {- Ok(Some(acp_thread::SubmissionResponse::LegacyCompleted(response))) => {- eprintln!("[eval-cli] stopped: {:?}", response.stop_reason);- if response.stop_reason == acp::StopReason::MaxTokens {+ Ok(stop_reason) => {+ eprintln!("[eval-cli] stopped: {:?}", stop_reason);+ if let acp_v2::StopReason::Error(details) = stop_reason {+ Err(details+ .error+ .map(|error| anyhow::Error::new(*error))+ .unwrap_or_else(|| anyhow::anyhow!("Agent stopped because of an error")))+ } else if stop_reason == acp_v2::StopReason::MaxTokens {Err(anyhow::anyhow!("Model hit maximum token limit"))} else {Ok(AgentOutcome::Completed)}}- Ok(Some(acp_thread::SubmissionResponse::Accepted(_))) => {- Err(anyhow::anyhow!("Native agent returned acceptance instead of turn completion"))- }- Ok(None) => {- eprintln!("[eval-cli] completed (no response)");- Ok(AgentOutcome::Completed)- }Err(e) => Err(e).context("agent run failed"),},_ = sigterm_future.fuse() => {