Reuse conversation cache when streaming edits (#30245)

Release Notes:

- Improved latency when the agent applies edits.

crates/agent/src/tool_use.rs

@@ -7,8 +7,8 @@ use futures::FutureExt as _;
 use futures::future::Shared;
 use gpui::{App, Entity, SharedString, Task};
 use language_model::{
-    ConfiguredModel, LanguageModel, LanguageModelRequestMessage, LanguageModelToolResult,
-    LanguageModelToolUse, LanguageModelToolUseId, MessageContent, Role,
+    ConfiguredModel, LanguageModel, LanguageModelRequest, LanguageModelToolResult,
+    LanguageModelToolUse, LanguageModelToolUseId, Role,
 };
 use project::Project;
 use ui::{IconName, Window};
@@ -354,7 +354,7 @@ impl ToolUseState {
         tool_use_id: LanguageModelToolUseId,
         ui_text: impl Into<Arc<str>>,
         input: serde_json::Value,
-        messages: Arc<Vec<LanguageModelRequestMessage>>,
+        request: Arc<LanguageModelRequest>,
         tool: Arc<dyn Tool>,
     ) {
         if let Some(tool_use) = self.pending_tool_uses_by_id.get_mut(&tool_use_id) {
@@ -363,7 +363,7 @@ impl ToolUseState {
             let confirmation = Confirmation {
                 tool_use_id,
                 input,
-                messages,
+                request,
                 tool,
                 ui_text,
             };
@@ -449,72 +449,20 @@ impl ToolUseState {
         }
     }
 
-    pub fn attach_tool_uses(
-        &self,
-        message_id: MessageId,
-        request_message: &mut LanguageModelRequestMessage,
-    ) {
-        if let Some(tool_uses) = self.tool_uses_by_assistant_message.get(&message_id) {
-            for tool_use in tool_uses {
-                if self.tool_results.contains_key(&tool_use.id) {
-                    // Do not send tool uses until they are completed
-                    request_message
-                        .content
-                        .push(MessageContent::ToolUse(tool_use.clone()));
-                } else {
-                    log::debug!(
-                        "skipped tool use {:?} because it is still pending",
-                        tool_use
-                    );
-                }
-            }
-        }
-    }
-
     pub fn has_tool_results(&self, assistant_message_id: MessageId) -> bool {
         self.tool_uses_by_assistant_message
             .contains_key(&assistant_message_id)
     }
 
-    pub fn tool_results_message(
+    pub fn tool_results(
         &self,
         assistant_message_id: MessageId,
-    ) -> Option<LanguageModelRequestMessage> {
-        let tool_uses = self
-            .tool_uses_by_assistant_message
-            .get(&assistant_message_id)?;
-
-        if tool_uses.is_empty() {
-            return None;
-        }
-
-        let mut request_message = LanguageModelRequestMessage {
-            role: Role::User,
-            content: vec![],
-            cache: false,
-        };
-
-        for tool_use in tool_uses {
-            if let Some(tool_result) = self.tool_results.get(&tool_use.id) {
-                request_message
-                    .content
-                    .push(MessageContent::ToolResult(LanguageModelToolResult {
-                        tool_use_id: tool_use.id.clone(),
-                        tool_name: tool_result.tool_name.clone(),
-                        is_error: tool_result.is_error,
-                        content: if tool_result.content.is_empty() {
-                            // Surprisingly, the API fails if we return an empty string here.
-                            // It thinks we are sending a tool use without a tool result.
-                            "<Tool returned an empty string>".into()
-                        } else {
-                            tool_result.content.clone()
-                        },
-                        output: None,
-                    }));
-            }
-        }
-
-        Some(request_message)
+    ) -> impl Iterator<Item = (&LanguageModelToolUse, Option<&LanguageModelToolResult>)> {
+        self.tool_uses_by_assistant_message
+            .get(&assistant_message_id)
+            .into_iter()
+            .flatten()
+            .map(|tool_use| (tool_use, self.tool_results.get(&tool_use.id)))
     }
 }
 
@@ -535,7 +483,7 @@ pub struct Confirmation {
     pub tool_use_id: LanguageModelToolUseId,
     pub input: serde_json::Value,
     pub ui_text: Arc<str>,
-    pub messages: Arc<Vec<LanguageModelRequestMessage>>,
+    pub request: Arc<LanguageModelRequest>,
     pub tool: Arc<dyn Tool>,
 }