Render our code edit tool use differently

This reverts commit e82987db19286a18779f9e2e9d634d9cf98672ee.

assets/prompts/suggest_edits.hbs

@@ -1,206 +0,0 @@
-<task_description>
-
-The user of a code editor wants to make a change to their codebase.
-You must describe the change using the following XML structure:
-
-- <patch> - A group of related code changes.
-  Child tags:
-    - <title> (required) - A high-level description of the changes. This should be as short
-      as possible, possibly using common abbreviations.
-    - <edit> (1 or more) - An edit to make at a particular range within a file.
-      Includes the following child tags:
-        - <path> (required) - The path to the file that will be changed.
-        - <description> (optional) - An arbitrarily-long comment that describes the purpose
-          of this edit.
-        - <old_text> (optional) - An excerpt from the file's current contents that uniquely
-          identifies a range within the file where the edit should occur. If this tag is not
-          specified, then the entire file will be used as the range.
-        - <new_text> (required) - The new text to insert into the file.
-        - <operation> (required) - The type of change that should occur at the given range
-          of the file. Must be one of the following values:
-            - `update`: Replaces the entire range with the new text.
-            - `insert_before`: Inserts the new text before the range.
-            - `insert_after`: Inserts new text after the range.
-            - `create`: Creates a new file with the given path and the new text.
-            - `delete`: Deletes the specified range from the file.
-
-<guidelines>
-- Never provide multiple edits whose ranges intersect each other. Instead, merge them into one edit.
-- Prefer multiple edits to smaller, disjoint ranges, rather than one edit to a larger range.
-- There's no need to escape angle brackets within XML tags.
-- Always ensure imports are added if you're referencing symbols that are not in scope.
-</guidelines>
-
-Here are some concrete examples.
-
-<example>
-<message role="user">
-
-```rs src/shapes.rs
-pub mod rectangle;
-pub mod circle;
-```
-
-```rs src/shapes/rectangle.rs
-pub struct Rectangle {
-    width: f64,
-    height: f64,
-}
-
-impl Rectangle {
-    pub fn new(width: f64, height: f64) -> Self {
-        Rectangle { width, height }
-    }
-}
-```
-
-```rs src/shapes/circle.rs
-pub struct Circle {
-    radius: f64,
-}
-
-impl Circle {
-    pub fn new(radius: f64) -> Self {
-        Circle { radius }
-    }
-}
-```
-
-Update all shapes to store their origin as an (x, y) tuple and implement Display.
-</message>
-
-<message role="assistant">
-We'll need to update both the rectangle and circle modules.
-
-<patch>
-<title>Add origins and display impls to shapes</title>
-<edit>
-<path>src/shapes/rectangle.rs</path>
-<description>Add the origin field to Rectangle struct</description>
-<operation>insert_after</operation>
-<old_text>
-pub struct Rectangle {
-</old_text>
-<new_text>
-origin: (f64, f64),
-</new_text>
-</edit>
-
-<edit>
-<path>src/shapes/rectangle.rs</path>
-<operation>update</operation>
-<old_text>
-fn new(width: f64, height: f64) -> Self {
-    Rectangle { width, height }
-}
-</old_text>
-<new_text>
-fn new(origin: (f64, f64), width: f64, height: f64) -> Self {
-    Rectangle { origin, width, height }
-}
-</new_text>
-</edit>
-
-<edit>
-<path>src/shapes/circle.rs</path>
-<description>Add the origin field to Circle struct</description>
-<operation>insert_after</operation>
-<old_text>
-pub struct Circle {
-    radius: f64,
-</old_text>
-<new_text>
-    origin: (f64, f64),
-</new_text>
-</edit>
-
-<edit>
-<path>src/shapes/circle.rs</path>
-<operation>update</operation>
-<old_text>
-fn new(radius: f64) -> Self {
-    Circle { radius }
-}
-</old_text>
-<new_text>
-fn new(origin: (f64, f64), radius: f64) -> Self {
-    Circle { origin, radius }
-}
-</new_text>
-</edit>
-</step>
-
-<edit>
-<path>src/shapes/rectangle.rs</path>
-<operation>insert_before</operation>
-<old_text>
-struct Rectangle {
-</old_text>
-<new_text>
-use std::fmt;
-
-</new_text>
-</edit>
-
-<edit>
-<path>src/shapes/rectangle.rs</path>
-<description>
-Add a manual Display implementation for Rectangle.
-Currently, this is the same as a derived Display implementation.
-</description>
-<operation>insert_after</operation>
-<old_text>
-        Rectangle { width, height }
-    }
-}
-</old_text>
-<new_text>
-impl fmt::Display for Rectangle {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.format_struct(f, "Rectangle")
-            .field("origin", &self.origin)
-            .field("width", &self.width)
-            .field("height", &self.height)
-            .finish()
-    }
-}
-</new_text>
-</edit>
-
-<edit>
-<path>src/shapes/circle.rs</path>
-<operation>insert_before</operation>
-<old_text>
-struct Circle {
-</old_text>
-<new_text>
-use std::fmt;
-</new_text>
-</edit>
-
-<edit>
-<path>src/shapes/circle.rs</path>
-<operation>insert_after</operation>
-<old_text>
-        Circle { radius }
-    }
-}
-</old_text>
-<new_text>
-impl fmt::Display for Rectangle {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.format_struct(f, "Rectangle")
-            .field("origin", &self.origin)
-            .field("width", &self.width)
-            .field("height", &self.height)
-            .finish()
-    }
-}
-</new_text>
-</edit>
-</patch>
-
-</message>
-</example>
-
-</task_description>

crates/anthropic/src/anthropic.rs

@@ -1,13 +1,12 @@
 mod supported_countries;
 
-use std::{pin::Pin, str::FromStr};
-
 use anyhow::{anyhow, Context, Result};
 use chrono::{DateTime, Utc};
 use futures::{io::BufReader, stream::BoxStream, AsyncBufReadExt, AsyncReadExt, Stream, StreamExt};
 use http_client::http::{HeaderMap, HeaderValue};
 use http_client::{AsyncBody, HttpClient, Method, Request as HttpRequest};
 use serde::{Deserialize, Serialize};
+use std::{pin::Pin, str::FromStr};
 use strum::{EnumIter, EnumString};
 use thiserror::Error;
 use util::ResultExt as _;

crates/assistant/src/assistant_panel.rs

@@ -1,5 +1,6 @@
 use crate::slash_command::file_command::codeblock_fence_for_path;
 use crate::slash_command_working_set::SlashCommandWorkingSet;
+use crate::tools::code_edits_tool::{CodeEditsTool, CodeEditsToolInput};
 use crate::ToolWorkingSet;
 use crate::{
     assistant_settings::{AssistantDockPosition, AssistantSettings},
@@ -1898,47 +1899,111 @@ impl ContextEditor {
                     let creases = new_tool_uses
                         .iter()
                         .map(|tool_use| {
-                            let placeholder = FoldPlaceholder {
-                                render: render_fold_icon_button(
-                                    cx.view().downgrade(),
-                                    IconName::PocketKnife,
-                                    tool_use.name.clone().into(),
-                                ),
-                                ..Default::default()
-                            };
-                            let render_trailer =
-                                move |_row, _unfold, _cx: &mut WindowContext| Empty.into_any();
+                            if &tool_use.name == CodeEditsTool::TOOL_NAME {
+                                // If this is a Code Edit tool,
+                                match serde_json::from_value::<CodeEditsToolInput>(
+                                    tool_use.input.clone(),
+                                ) {
+                                    Ok(CodeEditsToolInput { title, edits }) => {
+                                        let placeholder = FoldPlaceholder {
+                                            render: render_fold_icon_button(
+                                                cx.view().downgrade(),
+                                                IconName::Sparkle,
+                                                title.into(),
+                                            ),
+                                            ..Default::default()
+                                        };
+                                        let render_trailer =
+                                            move |_row, _unfold, _cx: &mut WindowContext| {
+                                                Empty.into_any()
+                                            };
 
-                            let start = buffer
-                                .anchor_in_excerpt(excerpt_id, tool_use.source_range.start)
-                                .unwrap();
-                            let end = buffer
-                                .anchor_in_excerpt(excerpt_id, tool_use.source_range.end)
-                                .unwrap();
+                                        let start = buffer
+                                            .anchor_in_excerpt(
+                                                excerpt_id,
+                                                tool_use.source_range.start,
+                                            )
+                                            .unwrap();
+                                        let end = buffer
+                                            .anchor_in_excerpt(
+                                                excerpt_id,
+                                                tool_use.source_range.end,
+                                            )
+                                            .unwrap();
 
-                            let buffer_row = MultiBufferRow(start.to_point(&buffer).row);
-                            buffer_rows_to_fold.insert(buffer_row);
+                                        let buffer_row =
+                                            MultiBufferRow(start.to_point(&buffer).row);
+                                        buffer_rows_to_fold.insert(buffer_row);
 
-                            self.context.update(cx, |context, cx| {
-                                context.insert_content(
-                                    Content::ToolUse {
-                                        range: tool_use.source_range.clone(),
-                                        tool_use: LanguageModelToolUse {
-                                            id: tool_use.id.to_string(),
-                                            name: tool_use.name.clone(),
-                                            input: tool_use.input.clone(),
+                                        self.context.update(cx, |context, cx| {
+                                            context.insert_content(
+                                                Content::ToolUse {
+                                                    range: tool_use.source_range.clone(),
+                                                    tool_use: LanguageModelToolUse {
+                                                        id: tool_use.id.to_string(),
+                                                        name: tool_use.name.clone(),
+                                                        input: tool_use.input.clone(),
+                                                    },
+                                                },
+                                                cx,
+                                            );
+                                        });
+
+                                        Crease::inline(
+                                            start..end,
+                                            placeholder,
+                                            fold_toggle("tool-use"),
+                                            render_trailer,
+                                        )
+                                    }
+                                    Err(json_err) => {
+                                        // TODO gracefully handle malformed JSON (should distinguish from "errored out" vs "not done streaming yet")
+                                        todo!();
+                                    }
+                                }
+                            } else {
+                                let placeholder = FoldPlaceholder {
+                                    render: render_fold_icon_button(
+                                        cx.view().downgrade(),
+                                        IconName::PocketKnife,
+                                        tool_use.name.clone().into(),
+                                    ),
+                                    ..Default::default()
+                                };
+                                let render_trailer =
+                                    move |_row, _unfold, _cx: &mut WindowContext| Empty.into_any();
+
+                                let start = buffer
+                                    .anchor_in_excerpt(excerpt_id, tool_use.source_range.start)
+                                    .unwrap();
+                                let end = buffer
+                                    .anchor_in_excerpt(excerpt_id, tool_use.source_range.end)
+                                    .unwrap();
+
+                                let buffer_row = MultiBufferRow(start.to_point(&buffer).row);
+                                buffer_rows_to_fold.insert(buffer_row);
+
+                                self.context.update(cx, |context, cx| {
+                                    context.insert_content(
+                                        Content::ToolUse {
+                                            range: tool_use.source_range.clone(),
+                                            tool_use: LanguageModelToolUse {
+                                                id: tool_use.id.to_string(),
+                                                name: tool_use.name.clone(),
+                                                input: tool_use.input.clone(),
+                                            },
                                         },
-                                    },
-                                    cx,
-                                );
-                            });
+                                        cx,
+                                    );
+                                });
 
-                            Crease::inline(
-                                start..end,
-                                placeholder,
-                                fold_toggle("tool-use"),
-                                render_trailer,
-                            )
+                                Crease::inline(
+                                    start..end,
+                                    placeholder,
+                                    fold_toggle("tool-use"),
+                                    render_trailer,
+                                )
+                            }
                         })
                         .collect::<Vec<_>>();
 

crates/assistant/src/context.rs

@@ -6,12 +6,14 @@ use crate::ToolWorkingSet;
 use crate::{
     prompts::PromptBuilder,
     slash_command::{file_command::FileCommandMetadata, SlashCommandLine},
-    AssistantEdit, AssistantPatch, AssistantPatchStatus, MessageId, MessageStatus,
+    tools::code_edits_tool::CodeEditsTool,
+    AssistantPatch, MessageId, MessageStatus,
 };
 use anyhow::{anyhow, Context as _, Result};
 use assistant_slash_command::{
     SlashCommandContent, SlashCommandEvent, SlashCommandOutputSection, SlashCommandResult,
 };
+use assistant_tool::Tool;
 use client::{self, proto, telemetry::Telemetry};
 use clock::ReplicaId;
 use collections::{HashMap, HashSet};
@@ -43,7 +45,6 @@ use std::{
     iter, mem,
     ops::Range,
     path::{Path, PathBuf},
-    str::FromStr as _,
     sync::Arc,
     time::{Duration, Instant},
 };
@@ -561,7 +562,6 @@ pub struct Context {
     telemetry: Option<Arc<Telemetry>>,
     language_registry: Arc<LanguageRegistry>,
     patches: Vec<AssistantPatch>,
-    xml_tags: Vec<XmlTag>,
     project: Option<Model<Project>>,
     prompt_builder: Arc<PromptBuilder>,
 }
@@ -670,7 +670,6 @@ impl Context {
             slash_commands,
             tools,
             patches: Vec::new(),
-            xml_tags: Vec::new(),
             prompt_builder,
         };
 
@@ -962,7 +961,6 @@ impl Context {
         }
 
         if !changed_messages.is_empty() {
-            self.message_roles_updated(changed_messages, cx);
             cx.emit(ContextEvent::MessagesEdited);
             cx.notify();
         }
@@ -1386,8 +1384,6 @@ impl Context {
 
         let mut removed_parsed_slash_command_ranges = Vec::new();
         let mut updated_parsed_slash_commands = Vec::new();
-        let mut removed_patches = Vec::new();
-        let mut updated_patches = Vec::new();
         while let Some(mut row_range) = row_ranges.next() {
             while let Some(next_row_range) = row_ranges.peek() {
                 if row_range.end >= next_row_range.start {
@@ -1412,13 +1408,6 @@ impl Context {
                 cx,
             );
             self.invalidate_pending_slash_commands(&buffer, cx);
-            self.reparse_patches_in_range(
-                start..end,
-                &buffer,
-                &mut updated_patches,
-                &mut removed_patches,
-                cx,
-            );
         }
 
         if !updated_parsed_slash_commands.is_empty()
@@ -1429,13 +1418,6 @@ impl Context {
                 updated: updated_parsed_slash_commands,
             });
         }
-
-        if !updated_patches.is_empty() || !removed_patches.is_empty() {
-            cx.emit(ContextEvent::PatchesUpdated {
-                removed: removed_patches,
-                updated: updated_patches,
-            });
-        }
     }
 
     fn reparse_slash_commands_in_range(
@@ -1526,267 +1508,6 @@ impl Context {
         }
     }
 
-    fn reparse_patches_in_range(
-        &mut self,
-        range: Range<text::Anchor>,
-        buffer: &BufferSnapshot,
-        updated: &mut Vec<Range<text::Anchor>>,
-        removed: &mut Vec<Range<text::Anchor>>,
-        cx: &mut ModelContext<Self>,
-    ) {
-        // Rebuild the XML tags in the edited range.
-        let intersecting_tags_range =
-            self.indices_intersecting_buffer_range(&self.xml_tags, range.clone(), cx);
-        let new_tags = self.parse_xml_tags_in_range(buffer, range.clone(), cx);
-        self.xml_tags
-            .splice(intersecting_tags_range.clone(), new_tags);
-
-        // Find which patches intersect the changed range.
-        let intersecting_patches_range =
-            self.indices_intersecting_buffer_range(&self.patches, range.clone(), cx);
-
-        // Reparse all tags after the last unchanged patch before the change.
-        let mut tags_start_ix = 0;
-        if let Some(preceding_unchanged_patch) =
-            self.patches[..intersecting_patches_range.start].last()
-        {
-            tags_start_ix = match self.xml_tags.binary_search_by(|tag| {
-                tag.range
-                    .start
-                    .cmp(&preceding_unchanged_patch.range.end, buffer)
-                    .then(Ordering::Less)
-            }) {
-                Ok(ix) | Err(ix) => ix,
-            };
-        }
-
-        // Rebuild the patches in the range.
-        let new_patches = self.parse_patches(tags_start_ix, range.end, buffer, cx);
-        updated.extend(new_patches.iter().map(|patch| patch.range.clone()));
-        let removed_patches = self.patches.splice(intersecting_patches_range, new_patches);
-        removed.extend(
-            removed_patches
-                .map(|patch| patch.range)
-                .filter(|range| !updated.contains(&range)),
-        );
-    }
-
-    fn parse_xml_tags_in_range(
-        &self,
-        buffer: &BufferSnapshot,
-        range: Range<text::Anchor>,
-        cx: &AppContext,
-    ) -> Vec<XmlTag> {
-        let mut messages = self.messages(cx).peekable();
-
-        let mut tags = Vec::new();
-        let mut lines = buffer.text_for_range(range).lines();
-        let mut offset = lines.offset();
-
-        while let Some(line) = lines.next() {
-            while let Some(message) = messages.peek() {
-                if offset < message.offset_range.end {
-                    break;
-                } else {
-                    messages.next();
-                }
-            }
-
-            let is_assistant_message = messages
-                .peek()
-                .map_or(false, |message| message.role == Role::Assistant);
-            if is_assistant_message {
-                for (start_ix, _) in line.match_indices('<') {
-                    let mut name_start_ix = start_ix + 1;
-                    let closing_bracket_ix = line[start_ix..].find('>').map(|i| start_ix + i);
-                    if let Some(closing_bracket_ix) = closing_bracket_ix {
-                        let end_ix = closing_bracket_ix + 1;
-                        let mut is_open_tag = true;
-                        if line[name_start_ix..closing_bracket_ix].starts_with('/') {
-                            name_start_ix += 1;
-                            is_open_tag = false;
-                        }
-                        let tag_inner = &line[name_start_ix..closing_bracket_ix];
-                        let tag_name_len = tag_inner
-                            .find(|c: char| c.is_whitespace())
-                            .unwrap_or(tag_inner.len());
-                        if let Ok(kind) = XmlTagKind::from_str(&tag_inner[..tag_name_len]) {
-                            tags.push(XmlTag {
-                                range: buffer.anchor_after(offset + start_ix)
-                                    ..buffer.anchor_before(offset + end_ix),
-                                is_open_tag,
-                                kind,
-                            });
-                        };
-                    }
-                }
-            }
-
-            offset = lines.offset();
-        }
-        tags
-    }
-
-    fn parse_patches(
-        &mut self,
-        tags_start_ix: usize,
-        buffer_end: text::Anchor,
-        buffer: &BufferSnapshot,
-        cx: &AppContext,
-    ) -> Vec<AssistantPatch> {
-        let mut new_patches = Vec::new();
-        let mut pending_patch = None;
-        let mut patch_tag_depth = 0;
-        let mut tags = self.xml_tags[tags_start_ix..].iter().peekable();
-        'tags: while let Some(tag) = tags.next() {
-            if tag.range.start.cmp(&buffer_end, buffer).is_gt() && patch_tag_depth == 0 {
-                break;
-            }
-
-            if tag.kind == XmlTagKind::Patch && tag.is_open_tag {
-                patch_tag_depth += 1;
-                let patch_start = tag.range.start;
-                let mut edits = Vec::<Result<AssistantEdit>>::new();
-                let mut patch = AssistantPatch {
-                    range: patch_start..patch_start,
-                    title: String::new().into(),
-                    edits: Default::default(),
-                    status: crate::AssistantPatchStatus::Pending,
-                };
-
-                while let Some(tag) = tags.next() {
-                    if tag.kind == XmlTagKind::Patch && !tag.is_open_tag {
-                        patch_tag_depth -= 1;
-                        if patch_tag_depth == 0 {
-                            patch.range.end = tag.range.end;
-
-                            // Include the line immediately after this <patch> tag if it's empty.
-                            let patch_end_offset = patch.range.end.to_offset(buffer);
-                            let mut patch_end_chars = buffer.chars_at(patch_end_offset);
-                            if patch_end_chars.next() == Some('\n')
-                                && patch_end_chars.next().map_or(true, |ch| ch == '\n')
-                            {
-                                let messages = self.messages_for_offsets(
-                                    [patch_end_offset, patch_end_offset + 1],
-                                    cx,
-                                );
-                                if messages.len() == 1 {
-                                    patch.range.end = buffer.anchor_before(patch_end_offset + 1);
-                                }
-                            }
-
-                            edits.sort_unstable_by(|a, b| {
-                                if let (Ok(a), Ok(b)) = (a, b) {
-                                    a.path.cmp(&b.path)
-                                } else {
-                                    Ordering::Equal
-                                }
-                            });
-                            patch.edits = edits.into();
-                            patch.status = AssistantPatchStatus::Ready;
-                            new_patches.push(patch);
-                            continue 'tags;
-                        }
-                    }
-
-                    if tag.kind == XmlTagKind::Title && tag.is_open_tag {
-                        let content_start = tag.range.end;
-                        while let Some(tag) = tags.next() {
-                            if tag.kind == XmlTagKind::Title && !tag.is_open_tag {
-                                let content_end = tag.range.start;
-                                patch.title =
-                                    trimmed_text_in_range(buffer, content_start..content_end)
-                                        .into();
-                                break;
-                            }
-                        }
-                    }
-
-                    if tag.kind == XmlTagKind::Edit && tag.is_open_tag {
-                        let mut path = None;
-                        let mut old_text = None;
-                        let mut new_text = None;
-                        let mut operation = None;
-                        let mut description = None;
-
-                        while let Some(tag) = tags.next() {
-                            if tag.kind == XmlTagKind::Edit && !tag.is_open_tag {
-                                edits.push(AssistantEdit::new(
-                                    path,
-                                    operation,
-                                    old_text,
-                                    new_text,
-                                    description,
-                                ));
-                                break;
-                            }
-
-                            if tag.is_open_tag
-                                && [
-                                    XmlTagKind::Path,
-                                    XmlTagKind::OldText,
-                                    XmlTagKind::NewText,
-                                    XmlTagKind::Operation,
-                                    XmlTagKind::Description,
-                                ]
-                                .contains(&tag.kind)
-                            {
-                                let kind = tag.kind;
-                                let content_start = tag.range.end;
-                                if let Some(tag) = tags.peek() {
-                                    if tag.kind == kind && !tag.is_open_tag {
-                                        let tag = tags.next().unwrap();
-                                        let content_end = tag.range.start;
-                                        let content = trimmed_text_in_range(
-                                            buffer,
-                                            content_start..content_end,
-                                        );
-                                        match kind {
-                                            XmlTagKind::Path => path = Some(content),
-                                            XmlTagKind::Operation => operation = Some(content),
-                                            XmlTagKind::OldText => {
-                                                old_text = Some(content).filter(|s| !s.is_empty())
-                                            }
-                                            XmlTagKind::NewText => {
-                                                new_text = Some(content).filter(|s| !s.is_empty())
-                                            }
-                                            XmlTagKind::Description => {
-                                                description =
-                                                    Some(content).filter(|s| !s.is_empty())
-                                            }
-                                            _ => {}
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-
-                patch.edits = edits.into();
-                pending_patch = Some(patch);
-            }
-        }
-
-        if let Some(mut pending_patch) = pending_patch {
-            let patch_start = pending_patch.range.start.to_offset(buffer);
-            if let Some(message) = self.message_for_offset(patch_start, cx) {
-                if message.anchor_range.end == text::Anchor::MAX {
-                    pending_patch.range.end = text::Anchor::MAX;
-                } else {
-                    let message_end = buffer.anchor_after(message.offset_range.end - 1);
-                    pending_patch.range.end = message_end;
-                }
-            } else {
-                pending_patch.range.end = text::Anchor::MAX;
-            }
-
-            new_patches.push(pending_patch);
-        }
-
-        new_patches
-    }
-
     pub fn pending_command_for_position(
         &mut self,
         position: language::Anchor,
@@ -2471,9 +2192,22 @@ impl Context {
             }
         }
 
+        let tools = if let RequestType::SuggestEdits = request_type {
+            vec![{
+                let tool = CodeEditsTool;
+                LanguageModelRequestTool {
+                    name: tool.name(),
+                    description: tool.description(),
+                    input_schema: tool.input_schema(),
+                }
+            }]
+        } else {
+            Vec::new()
+        };
+
         let mut completion_request = LanguageModelRequest {
             messages: Vec::new(),
-            tools: Vec::new(),
+            tools,
             stop: Vec::new(),
             temperature: None,
         };
@@ -2546,25 +2280,6 @@ impl Context {
             completion_request.messages.push(request_message);
         }
 
-        if let RequestType::SuggestEdits = request_type {
-            if let Ok(preamble) = self.prompt_builder.generate_suggest_edits_prompt() {
-                let last_elem_index = completion_request.messages.len();
-
-                completion_request
-                    .messages
-                    .push(LanguageModelRequestMessage {
-                        role: Role::User,
-                        content: vec![MessageContent::Text(preamble)],
-                        cache: false,
-                    });
-
-                // The preamble message should be sent right before the last actual user message.
-                completion_request
-                    .messages
-                    .swap(last_elem_index, last_elem_index.saturating_sub(1));
-            }
-        }
-
         completion_request
     }
 
@@ -2588,28 +2303,6 @@ impl Context {
                 self.update_metadata(*id, cx, |metadata| metadata.role = role);
             }
         }
-
-        self.message_roles_updated(ids, cx);
-    }
-
-    fn message_roles_updated(&mut self, ids: HashSet<MessageId>, cx: &mut ModelContext<Self>) {
-        let mut ranges = Vec::new();
-        for message in self.messages(cx) {
-            if ids.contains(&message.id) {
-                ranges.push(message.anchor_range.clone());
-            }
-        }
-
-        let buffer = self.buffer.read(cx).text_snapshot();
-        let mut updated = Vec::new();
-        let mut removed = Vec::new();
-        for range in ranges {
-            self.reparse_patches_in_range(range, &buffer, &mut updated, &mut removed, cx);
-        }
-
-        if !updated.is_empty() || !removed.is_empty() {
-            cx.emit(ContextEvent::PatchesUpdated { removed, updated })
-        }
     }
 
     pub fn update_metadata(

crates/assistant/src/context/context_tests.rs

@@ -1,11 +1,11 @@
-use super::{AssistantEdit, MessageCacheMetadata};
+use super::MessageCacheMetadata;
 use crate::slash_command_working_set::SlashCommandWorkingSet;
-use crate::ToolWorkingSet;
 use crate::{
     assistant_panel, prompt_library, slash_command::file_command, AssistantEditKind, CacheStatus,
     Context, ContextEvent, ContextId, ContextOperation, InvokedSlashCommandId, MessageId,
     MessageStatus, PromptBuilder,
 };
+use crate::{AssistantEdit, ToolWorkingSet};
 use anyhow::Result;
 use assistant_slash_command::{
     ArgumentCompletion, SlashCommand, SlashCommandContent, SlashCommandEvent, SlashCommandOutput,

crates/assistant/src/prompts.rs

@@ -310,10 +310,6 @@ impl PromptBuilder {
             .render("terminal_assistant_prompt", &context)
     }
 
-    pub fn generate_suggest_edits_prompt(&self) -> Result<String, RenderError> {
-        self.handlebars.lock().render("suggest_edits", &())
-    }
-
     pub fn generate_project_slash_command_prompt(
         &self,
         context_buffer: String,

crates/assistant/src/tools.rs

@@ -1,2 +1,3 @@
+pub mod code_edits_tool;
 pub mod context_server_tool;
 pub mod now_tool;

crates/assistant/src/tools/code_edits_tool.rs

@@ -0,0 +1,86 @@
+use std::sync::Arc;
+
+use anyhow::{anyhow, Result};
+use assistant_tool::Tool;
+use gpui::{Task, WeakView, WindowContext};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct CodeEditsToolInput {
+    /// A high-level description of the code changes. This should be as short as possible, possibly using common abbreviations.
+    pub title: String,
+    /// An array of edits to be applied.
+    pub edits: Vec<Edit>,
+}
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct Edit {
+    /// The path to the file that this edit will change.
+    pub path: String,
+    /// An arbitrarily-long comment that describes the purpose of this edit.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    /// An excerpt from the file's current contents that uniquely identifies a range within the file where the edit should occur.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub old_text: Option<String>,
+    /// The new text to insert into the file.
+    pub new_text: String,
+    /// The type of change that should occur at the given range of the file.
+    pub operation: Operation,
+}
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum Operation {
+    /// Replaces the entire range with the new text.
+    Update,
+    /// Inserts the new text before the range.
+    InsertBefore,
+    /// Inserts new text after the range.
+    InsertAfter,
+    /// Creates a new file with the given path and the new text.
+    Create,
+    /// Deletes the specified range from the file.
+    Delete,
+}
+
+pub struct CodeEditsTool;
+
+impl CodeEditsTool {
+    pub const TOOL_NAME: &str = "zed_code_edits";
+}
+
+impl Tool for CodeEditsTool {
+    fn name(&self) -> String {
+        Self::TOOL_NAME.to_string()
+    }
+
+    fn description(&self) -> String {
+        // Anthropic's best practices for tool descriptions:
+        // https://docs.anthropic.com/en/docs/build-with-claude/tool-use#best-practices-for-tool-definitions
+        include_str!("edit_tool_description.txt").to_string()
+    }
+
+    fn input_schema(&self) -> serde_json::Value {
+        let schema = schemars::schema_for!(CodeEditsToolInput);
+
+        serde_json::to_value(&schema).unwrap()
+    }
+
+    fn run(
+        self: Arc<Self>,
+        input: serde_json::Value,
+        _workspace: WeakView<workspace::Workspace>,
+        _cx: &mut WindowContext,
+    ) -> Task<Result<String>> {
+        let input: CodeEditsToolInput = match serde_json::from_value(input) {
+            Ok(input) => input,
+            Err(err) => return Task::ready(Err(anyhow!(err))),
+        };
+
+        let text = format!("The tool returned {:?}.", input);
+
+        Task::ready(Ok(text))
+    }
+}

crates/assistant/src/tools/edit_tool_description.txt

@@ -0,0 +1,15 @@
+Describes the specific code changes that should be made to the files in a code base, based on the request the user made.
+It should be used when the user requests making changes to the code base, but not when the user is asking an question about information
+(including when asking for information about the code base) rather than requesting a change.
+
+The tool will return an array of patches, each of which represents some related modifications to the code base.
+Each patch contains a high-level summary of the changes (which will be displayed in the code editor),
+as well as an array of specific edits to be made to specific individual files. The code editor will apply each of those edits to the code base, or not, at the discretion of the user of the editor.
+
+Within each patch, the tool will never return multiple edits whose ranges intersect each other. Instead, it will merge them into one edit.
+On the other hand, for ranges that do not intersect each other, the tool will prefer multiple edits to smaller ranges over one edit to a larger range.
+
+Whenever edits reference symbols that would be out of scope, the tool will always include earlier edits which add any necessary imports to bring those symbols into scope.
+
+The overall goal is that if the user of the code editor accepts all edits within all patches, the code will end up in a correct state, and
+will successfully build and run without any further modifications from the user. It will also have correctly effected the changes to the code base that the user originally requested.