Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
acp: Support embedded resources in tool call content (#59821)
Ben Brandt2df74932bc66
diff --git a/Cargo.lock b/Cargo.lockindex 069a21006e7..4e1f6c99023 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -116,6 +116,7 @@ dependencies = ["language_model","log","markdown",+ "mime","multi_buffer","parking_lot","portable-pty",diff --git a/Cargo.toml b/Cargo.tomlindex 4fb73966008..611ecf2a258 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -392,6 +392,7 @@ mermaid_render = { path = "crates/mermaid_render" }svg_preview = { path = "crates/svg_preview" }media = { path = "crates/media" }menu = { path = "crates/menu" }+mime = "0.3.17"migrator = { path = "crates/migrator" }mistral = { path = "crates/mistral" }multi_buffer = { path = "crates/multi_buffer" }diff --git a/crates/acp_thread/Cargo.toml b/crates/acp_thread/Cargo.tomlindex d92fd6b1fec..3c4f592a554 100644--- a/crates/acp_thread/Cargo.toml+++ b/crates/acp_thread/Cargo.toml@@ -35,6 +35,7 @@ language.workspace = truelanguage_model.workspace = truelog.workspace = truemarkdown.workspace = true+mime.workspace = trueparking_lot = { workspace = true, optional = true }image.workspace = trueportable-pty.workspace = truediff --git a/crates/acp_thread/src/acp_thread.rs b/crates/acp_thread/src/acp_thread.rsindex cabdddfba19..1efe43188b4 100644--- a/crates/acp_thread/src/acp_thread.rs+++ b/crates/acp_thread/src/acp_thread.rs@@ -957,6 +957,10 @@ pub enum ContentBlock {Markdown {markdown: Entity<Markdown>,},+ EmbeddedResource {+ resource: acp::EmbeddedResource,+ markdown: Option<Entity<Markdown>>,+ },ResourceLink {resource_link: acp::ResourceLink,},@@ -991,6 +995,26 @@ impl ContentBlock {this}+ pub fn new_tool_call_content(+ block: acp::ContentBlock,+ language_registry: &Arc<LanguageRegistry>,+ path_style: PathStyle,+ cx: &mut App,+ ) -> Self {+ match block {+ acp::ContentBlock::Resource(resource) => {+ if let Some((image, dimensions)) = Self::decode_embedded_resource_image(&resource) {+ Self::Image { image, dimensions }+ } else {+ let markdown =+ Self::embedded_resource_markdown(&resource, language_registry, cx);+ Self::EmbeddedResource { resource, markdown }+ }+ }+ block => Self::new(block, language_registry, path_style, cx),+ }+ }+pub fn append(&mut self,block: acp::ContentBlock,@@ -1026,6 +1050,13 @@ impl ContentBlock {let combined = format!("{}\n{}", existing_content, new_content);*self = Self::create_markdown_block(combined, language_registry, cx);}+ (ContentBlock::EmbeddedResource { resource, .. }, _) => {+ let existing_content =+ Self::embedded_resource_string_contents(resource, path_style);+ let new_content = Self::block_string_contents(&block, path_style);+ let combined = format!("{}\n{}", existing_content, new_content);+ *self = Self::create_markdown_block(combined, language_registry, cx);+ }(ContentBlock::Image { .. }, _) => {let new_content = Self::block_string_contents(&block, path_style);let combined = format!("`Image`\n{}", new_content);@@ -1063,13 +1094,30 @@ impl ContentBlock {fn decode_image(image_content: &acp::ImageContent,+ ) -> Option<(Arc<gpui::Image>, Option<gpui::Size<u32>>)> {+ Self::decode_image_data(&image_content.data, &image_content.mime_type)+ }++ fn decode_embedded_resource_image(+ resource: &acp::EmbeddedResource,+ ) -> Option<(Arc<gpui::Image>, Option<gpui::Size<u32>>)> {+ let acp::EmbeddedResourceResource::BlobResourceContents(blob) = &resource.resource else {+ return None;+ };+ let mime_type = blob.mime_type.as_deref()?;+ Self::decode_image_data(&blob.blob, mime_type)+ }++ fn decode_image_data(+ data: &str,+ mime_type: &str,) -> Option<(Arc<gpui::Image>, Option<gpui::Size<u32>>)> {use base64::Engine as _;let bytes = base64::engine::general_purpose::STANDARD- .decode(image_content.data.as_bytes())+ .decode(data.as_bytes()).ok()?;- let format = gpui::ImageFormat::from_mime_type(&image_content.mime_type)?;+ let format = gpui::ImageFormat::from_mime_type(mime_type)?;let dimensions = Self::image_dimensions(&bytes, format);Some((Arc::new(gpui::Image::from_bytes(format, bytes)), dimensions))}@@ -1099,19 +1147,141 @@ impl ContentBlock {cx: &mut App,) -> ContentBlock {ContentBlock::Markdown {- markdown: cx.new(|cx| {- Markdown::new_with_options(- content.into(),- Some(language_registry.clone()),- None,- MarkdownOptions {- render_mermaid_diagrams: true,- render_metadata_blocks: true,- ..Default::default()- },- cx,- )- }),+ markdown: Self::create_markdown(content, language_registry, cx),+ }+ }++ fn create_markdown(+ content: String,+ language_registry: &Arc<LanguageRegistry>,+ cx: &mut App,+ ) -> Entity<Markdown> {+ cx.new(|cx| {+ Markdown::new_with_options(+ content.into(),+ Some(language_registry.clone()),+ None,+ MarkdownOptions {+ render_mermaid_diagrams: true,+ render_metadata_blocks: true,+ ..Default::default()+ },+ cx,+ )+ })+ }++ fn embedded_resource_markdown(+ resource: &acp::EmbeddedResource,+ language_registry: &Arc<LanguageRegistry>,+ cx: &mut App,+ ) -> Option<Entity<Markdown>> {+ match &resource.resource {+ acp::EmbeddedResourceResource::TextResourceContents(text) => Some(+ Self::create_markdown(Self::text_resource_markdown(text), language_registry, cx),+ ),+ acp::EmbeddedResourceResource::BlobResourceContents(_) => None,+ _ => None,+ }+ }++ fn text_resource_markdown(resource: &acp::TextResourceContents) -> String {+ match text_resource_render_mode(resource.mime_type.as_deref()) {+ TextResourceRenderMode::Markdown => resource.text.clone(),+ TextResourceRenderMode::CodeBlock(language) => {+ Self::fenced_code_block(&resource.text, language)+ }+ }+ }++ pub fn text_content<'a>(&'a self, cx: &'a App) -> Option<&'a str> {+ match self {+ ContentBlock::Markdown { markdown } => Some(markdown.read(cx).source()),+ ContentBlock::EmbeddedResource { resource, .. } => match &resource.resource {+ acp::EmbeddedResourceResource::TextResourceContents(text) => Some(&text.text),+ acp::EmbeddedResourceResource::BlobResourceContents(_) => None,+ _ => None,+ },+ ContentBlock::Empty+ | ContentBlock::ResourceLink { .. }+ | ContentBlock::Image { .. } => None,+ }+ }++ fn fenced_code_block(text: &str, language: Option<&str>) -> String {+ let fence_len = text+ .as_bytes()+ .chunk_by(|left, right| left == right)+ .filter(|chunk| chunk.first() == Some(&b'`'))+ .map(|chunk| chunk.len() + 1)+ .max()+ .unwrap_or(3)+ .max(3);+ let fence = "`".repeat(fence_len);++ let mut markdown = String::new();+ markdown.push_str(&fence);+ if let Some(language) = language {+ markdown.push_str(language);+ }+ markdown.push('\n');+ markdown.push_str(text);+ if !text.ends_with('\n') {+ markdown.push('\n');+ }+ markdown.push_str(&fence);+ markdown+ }++ fn embedded_resource_string_contents(+ resource: &acp::EmbeddedResource,+ path_style: PathStyle,+ ) -> String {+ match &resource.resource {+ acp::EmbeddedResourceResource::TextResourceContents(text) => {+ Self::resource_link_md(&text.uri, path_style)+ }+ acp::EmbeddedResourceResource::BlobResourceContents(blob) => {+ Self::resource_link_md(&blob.uri, path_style)+ }+ _ => String::new(),+ }+ }++ fn embedded_resource_text(resource: &acp::EmbeddedResource) -> &str {+ match &resource.resource {+ acp::EmbeddedResourceResource::TextResourceContents(text) => &text.text,+ acp::EmbeddedResourceResource::BlobResourceContents(blob) => &blob.uri,+ _ => "",+ }+ }++ fn embedded_resource_label(resource: &acp::EmbeddedResource) -> &str {+ match &resource.resource {+ acp::EmbeddedResourceResource::TextResourceContents(text) => &text.uri,+ acp::EmbeddedResourceResource::BlobResourceContents(blob) => &blob.uri,+ _ => "",+ }+ }++ pub fn embedded_resource(&self) -> Option<(&acp::EmbeddedResource, Option<&Entity<Markdown>>)> {+ match self {+ ContentBlock::EmbeddedResource { resource, markdown } => {+ Some((resource, markdown.as_ref()))+ }+ _ => None,+ }+ }++ pub fn visible_content(&self, cx: &App) -> bool {+ match self {+ ContentBlock::Empty => false,+ ContentBlock::Markdown { markdown } => !markdown.read(cx).source().trim().is_empty(),+ ContentBlock::EmbeddedResource { resource, markdown } => match markdown {+ Some(markdown) => !markdown.read(cx).source().trim().is_empty(),+ None => !Self::embedded_resource_text(resource).trim().is_empty(),+ },+ ContentBlock::ResourceLink { .. } | ContentBlock::Image { .. } => true,}}@@ -1150,6 +1320,13 @@ impl ContentBlock {match self {ContentBlock::Empty => "",ContentBlock::Markdown { markdown } => markdown.read(cx).source(),+ ContentBlock::EmbeddedResource { resource, markdown } => {+ if let Some(markdown) = markdown {+ markdown.read(cx).source()+ } else {+ Self::embedded_resource_label(resource)+ }+ }ContentBlock::ResourceLink { resource_link } => &resource_link.uri,ContentBlock::Image { .. } => "`Image`",}@@ -1159,6 +1336,7 @@ impl ContentBlock {match self {ContentBlock::Empty => None,ContentBlock::Markdown { markdown } => Some(markdown),+ ContentBlock::EmbeddedResource { markdown, .. } => markdown.as_ref(),ContentBlock::ResourceLink { .. } => None,ContentBlock::Image { .. } => None,}@@ -1179,6 +1357,61 @@ impl ContentBlock {}}+enum TextResourceRenderMode {+ Markdown,+ CodeBlock(Option<&'static str>),+}++fn text_resource_render_mode(mime_type: Option<&str>) -> TextResourceRenderMode {+ let Some(mime_type) = mime_type else {+ return TextResourceRenderMode::CodeBlock(None);+ };+ let Ok(mime) = mime_type.parse::<mime::Mime>() else {+ return TextResourceRenderMode::CodeBlock(None);+ };++ let type_ = mime.type_().as_str();+ let subtype = mime.subtype().as_str();+ let suffix = mime.suffix().map(|suffix| suffix.as_str());++ if matches!(+ (type_, subtype),+ ("text", "markdown") | ("text", "x-markdown")+ ) {+ return TextResourceRenderMode::Markdown;+ }++ let language = match (type_, subtype, suffix) {+ (_, "json", _) | (_, _, Some("json")) => Some("json"),+ (_, "xml", _) | (_, _, Some("xml")) => Some("xml"),+ ("text", "html", _) => Some("html"),+ ("text", "css", _) => Some("css"),+ ("text", "csv", _) => Some("csv"),+ ("text", "tab-separated-values", _) => Some("tsv"),+ ("text", "javascript", _) | ("application", "javascript", _) => Some("javascript"),+ ("application", "x-javascript", _) => Some("javascript"),+ ("text", "typescript", _) | ("application", "typescript", _) => Some("typescript"),+ ("text", "x-shellscript", _) | ("application", "x-shellscript", _) => Some("sh"),+ ("application", "x-sh", _) => Some("sh"),+ ("text", "x-python", _) => Some("python"),+ ("text", "x-rust", _) => Some("rust"),+ ("text", "x-go", _) => Some("go"),+ ("text", "x-ruby", _) => Some("ruby"),+ ("text", "x-c", _) => Some("c"),+ // `mime` parses `text/x-c++` as subtype `x-c+` with an empty suffix.+ ("text", "x-c+", Some("")) => Some("cpp"),+ ("text", "plain", _) => None,+ ("text", _, _) => None,+ ("application", "graphql", _) => Some("graphql"),+ ("application", "toml", _) => Some("toml"),+ ("application", "yaml", _) | ("application", "x-yaml", _) => Some("yaml"),+ (_, _, Some("yaml" | "yml")) => Some("yaml"),+ _ => return TextResourceRenderMode::CodeBlock(None),+ };++ TextResourceRenderMode::CodeBlock(language)+}+#[derive(Debug)]pub enum ToolCallContent {ContentBlock(ContentBlock),@@ -1195,14 +1428,14 @@ impl ToolCallContent {cx: &mut App,) -> Result<Option<Self>> {match content {- acp::ToolCallContent::Content(acp::Content { content, .. }) => {- Ok(Some(Self::ContentBlock(ContentBlock::new(+ acp::ToolCallContent::Content(acp::Content { content, .. }) => Ok(Some(+ Self::ContentBlock(ContentBlock::new_tool_call_content(content,&language_registry,path_style,cx,- ))))- }+ )),+ )),acp::ToolCallContent::Diff(diff) => Ok(Some(Self::Diff(cx.new(|cx| {Diff::finalized(diff.path.to_string_lossy().into_owned(),@@ -3858,6 +4091,206 @@ mod tests {});}+ #[test]+ fn text_resource_markdown_uses_mime_type_for_code_blocks() {+ let shell = acp::TextResourceContents::new("echo 'hello from exec test'", "tool://preview")+ .mime_type("text/x-shellscript".to_string());+ assert_eq!(+ ContentBlock::text_resource_markdown(&shell),+ "```sh\necho 'hello from exec test'\n```"+ );++ let markdown = acp::TextResourceContents::new("**approval** requested", "tool://preview")+ .mime_type("text/markdown".to_string());+ assert_eq!(+ ContentBlock::text_resource_markdown(&markdown),+ "**approval** requested"+ );++ let plain = acp::TextResourceContents::new("plain preview", "tool://preview")+ .mime_type("text/plain".to_string());+ assert_eq!(+ ContentBlock::text_resource_markdown(&plain),+ "```\nplain preview\n```"+ );++ let cpp = acp::TextResourceContents::new("int main() {}", "tool://preview")+ .mime_type("text/x-c++; charset=utf-8".to_string());+ assert_eq!(+ ContentBlock::text_resource_markdown(&cpp),+ "```cpp\nint main() {}\n```"+ );++ let untyped = acp::TextResourceContents::new("# plain preview", "tool://preview");+ assert_eq!(+ ContentBlock::text_resource_markdown(&untyped),+ "```\n# plain preview\n```"+ );+ }++ #[gpui::test]+ async fn test_tool_call_content_preserves_embedded_text_resource(+ cx: &mut gpui::TestAppContext,+ ) {+ init_test(cx);++ cx.update(|cx| {+ let language_registry =+ Arc::new(LanguageRegistry::test(cx.background_executor().clone()));+ let content = acp::ContentBlock::Resource(acp::EmbeddedResource::new(+ acp::EmbeddedResourceResource::TextResourceContents(+ acp::TextResourceContents::new("echo 'hello from exec test'", "tool://preview")+ .mime_type("text/x-shellscript".to_string()),+ ),+ ));++ let block = ContentBlock::new_tool_call_content(+ content,+ &language_registry,+ PathStyle::local(),+ cx,+ );++ let ContentBlock::EmbeddedResource { resource, markdown } = &block else {+ panic!("expected embedded resource block, got {block:?}");+ };+ match &resource.resource {+ acp::EmbeddedResourceResource::TextResourceContents(text) => {+ assert_eq!(text.text, "echo 'hello from exec test'");+ assert_eq!(text.uri, "tool://preview");+ assert_eq!(text.mime_type.as_deref(), Some("text/x-shellscript"));+ }+ other => panic!("expected text resource contents, got {other:?}"),+ }++ let markdown = markdown+ .as_ref()+ .expect("text resources should have renderable markdown")+ .read(cx)+ .source()+ .to_string();+ assert_eq!(markdown, "```sh\necho 'hello from exec test'\n```");+ assert_eq!(+ block.to_markdown(cx),+ "```sh\necho 'hello from exec test'\n```"+ );+ assert_eq!(block.text_content(cx), Some("echo 'hello from exec test'"));++ let untyped = ContentBlock::new_tool_call_content(+ acp::ContentBlock::Resource(acp::EmbeddedResource::new(+ acp::EmbeddedResourceResource::TextResourceContents(+ acp::TextResourceContents::new("# plain preview", "tool://preview"),+ ),+ )),+ &language_registry,+ PathStyle::local(),+ cx,+ );+ assert_eq!(untyped.to_markdown(cx), "```\n# plain preview\n```");+ assert_eq!(untyped.text_content(cx), Some("# plain preview"));+ });+ }++ #[gpui::test]+ async fn test_tool_call_content_renders_embedded_image_blob_resource(+ cx: &mut gpui::TestAppContext,+ ) {+ init_test(cx);++ cx.update(|cx| {+ let language_registry =+ Arc::new(LanguageRegistry::test(cx.background_executor().clone()));+ let image_blob = acp::ContentBlock::Resource(acp::EmbeddedResource::new(+ acp::EmbeddedResourceResource::BlobResourceContents(+ acp::BlobResourceContents::new(+ "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==",+ "tool://preview.png",+ )+ .mime_type("image/png".to_string()),+ ),+ ));++ let block = ContentBlock::new_tool_call_content(+ image_blob,+ &language_registry,+ PathStyle::local(),+ cx,+ );++ let ContentBlock::Image { image, dimensions } = &block else {+ panic!("expected image block, got {block:?}");+ };+ assert_eq!(image.format(), gpui::ImageFormat::Png);+ assert_eq!(+ dimensions.as_ref().map(|size| (size.width, size.height)),+ Some((1, 1))+ );+ assert_eq!(block.to_markdown(cx), "`Image`");+ assert_eq!(block.text_content(cx), None);+ });+ }++ #[gpui::test]+ async fn test_tool_call_content_falls_back_for_non_image_blob_resource(+ cx: &mut gpui::TestAppContext,+ ) {+ init_test(cx);++ cx.update(|cx| {+ let language_registry =+ Arc::new(LanguageRegistry::test(cx.background_executor().clone()));+ let archive_blob = acp::ContentBlock::Resource(acp::EmbeddedResource::new(+ acp::EmbeddedResourceResource::BlobResourceContents(+ acp::BlobResourceContents::new("not an image", "tool://archive.bin")+ .mime_type("application/octet-stream".to_string()),+ ),+ ));++ let block = ContentBlock::new_tool_call_content(+ archive_blob,+ &language_registry,+ PathStyle::local(),+ cx,+ );++ let ContentBlock::EmbeddedResource { resource, markdown } = &block else {+ panic!("expected embedded resource block, got {block:?}");+ };+ assert!(markdown.is_none());+ match &resource.resource {+ acp::EmbeddedResourceResource::BlobResourceContents(blob) => {+ assert_eq!(blob.uri, "tool://archive.bin");+ assert_eq!(blob.mime_type.as_deref(), Some("application/octet-stream"));+ }+ other => panic!("expected blob resource contents, got {other:?}"),+ }+ assert_eq!(block.to_markdown(cx), "tool://archive.bin");+ assert_eq!(block.text_content(cx), None);++ let invalid_image_blob = acp::ContentBlock::Resource(acp::EmbeddedResource::new(+ acp::EmbeddedResourceResource::BlobResourceContents(+ acp::BlobResourceContents::new("not-base64", "tool://preview.png")+ .mime_type("image/png".to_string()),+ ),+ ));+ let invalid = ContentBlock::new_tool_call_content(+ invalid_image_blob,+ &language_registry,+ PathStyle::local(),+ cx,+ );+ let ContentBlock::EmbeddedResource { resource, markdown } = &invalid else {+ panic!("expected embedded resource block, got {invalid:?}");+ };+ assert!(markdown.is_none());+ assert_eq!(+ ContentBlock::embedded_resource_label(resource),+ "tool://preview.png"+ );+ assert_eq!(invalid.to_markdown(cx), "tool://preview.png");+ });+ }+#[test]fn sandbox_authorization_details_deserialize_legacy_network_bool() {// Older builds persisted `network: bool`; the `alias` on@@ -6100,6 +6533,9 @@ mod tests {ContentBlock::ResourceLink { .. } => {panic!("Expected markdown content, got resource link")}+ ContentBlock::EmbeddedResource { .. } => {+ panic!("Expected markdown content, got embedded resource")+ }ContentBlock::Image { .. } => {panic!("Expected markdown content, got image")}diff --git a/crates/agent_ui/src/conversation_view/thread_search_bar.rs b/crates/agent_ui/src/conversation_view/thread_search_bar.rsindex 80925e4b793..6563046ca1d 100644--- a/crates/agent_ui/src/conversation_view/thread_search_bar.rs+++ b/crates/agent_ui/src/conversation_view/thread_search_bar.rs@@ -920,8 +920,13 @@ fn collect_markdowns(ToolCallContent::ContentBlock(ContentBlock::Markdown { markdown }) => {Some(markdown.clone())}+ ToolCallContent::ContentBlock(ContentBlock::EmbeddedResource {+ markdown: Some(markdown),+ ..+ }) => Some(markdown.clone()),ToolCallContent::ContentBlock(ContentBlock::Empty+ | ContentBlock::EmbeddedResource { markdown: None, .. }| ContentBlock::ResourceLink { .. }| ContentBlock::Image { .. },)diff --git a/crates/agent_ui/src/conversation_view/thread_view.rs b/crates/agent_ui/src/conversation_view/thread_view.rsindex 1a0137e001d..553519fb34c 100644--- a/crates/agent_ui/src/conversation_view/thread_view.rs+++ b/crates/agent_ui/src/conversation_view/thread_view.rs@@ -9,7 +9,7 @@ use agent_client_protocol::schema::v1 as acp;use std::cell::RefCell;use acp_thread::{- ContentBlock, PlanEntry, SandboxAuthorizationDetails, SandboxFallbackAuthorizationDetails,+ PlanEntry, SandboxAuthorizationDetails, SandboxFallbackAuthorizationDetails,SandboxNotAppliedReason,};use agent::{@@ -6179,15 +6179,7 @@ impl ThreadView {if matches!(tool_call.status, ToolCallStatus::Canceled) {let has_visible_content =tool_call.content.iter().any(|content| match content {- ToolCallContent::ContentBlock(block) => match block {- ContentBlock::Empty => false,- ContentBlock::Markdown { markdown } => {- !markdown.read(cx).source().trim().is_empty()- }- ContentBlock::ResourceLink { .. } | ContentBlock::Image { .. } => {- true- }- },+ ToolCallContent::ContentBlock(block) => block.visible_content(cx),ToolCallContent::Diff(_) | ToolCallContent::Terminal(_) => true,});if !has_visible_content {@@ -9527,7 +9519,18 @@ impl ThreadView {) -> AnyElement {match content {ToolCallContent::ContentBlock(content) => {- if let Some(resource_link) = content.resource_link() {+ if let Some((resource, markdown)) = content.embedded_resource() {+ self.render_embedded_resource_output(+ resource,+ markdown.cloned(),+ entry_ix,+ context_ix,+ tool_call,+ card_layout,+ window,+ cx,+ )+ } else if let Some(resource_link) = content.resource_link() {self.render_resource_link(resource_link, cx)} else if let Some(markdown) = content.markdown() {self.render_markdown_output(@@ -9539,16 +9542,9 @@ impl ThreadView {window,cx,)- } else if let Some((image, dimensions)) = content.image() {+ } else if let Some((image, _)) = content.image() {let location = tool_call.locations.first().cloned();- self.render_image_output(- entry_ix,- image.clone(),- dimensions,- location,- card_layout,- cx,- )+ self.render_image_output(entry_ix, image.clone(), location, card_layout, cx)} else {Empty.into_any_element()}@@ -9569,6 +9565,60 @@ impl ThreadView {}}+ fn render_embedded_resource_output(+ &self,+ resource: &acp::EmbeddedResource,+ markdown: Option<Entity<Markdown>>,+ entry_ix: usize,+ context_ix: usize,+ tool_call: &ToolCall,+ card_layout: bool,+ window: &Window,+ cx: &Context<Self>,+ ) -> AnyElement {+ if let Some(markdown) = markdown {+ return self.render_markdown_output(+ markdown,+ entry_ix,+ context_ix,+ tool_call,+ card_layout,+ window,+ cx,+ );+ }++ let uri = match &resource.resource {+ acp::EmbeddedResourceResource::BlobResourceContents(blob) => blob.uri.as_str(),+ acp::EmbeddedResourceResource::TextResourceContents(text) => text.uri.as_str(),+ _ => "",+ };++ v_flex()+ .gap_1()+ .map(|this| {+ if card_layout {+ this.p_2().when(context_ix > 0, |this| {+ this.border_t_1()+ .border_color(self.tool_card_border_color(cx))+ })+ } else {+ this.ml(rems(0.4))+ .px_3p5()+ .border_l_1()+ .border_color(self.tool_card_border_color(cx))+ }+ })+ .when(!uri.is_empty(), |this| {+ this.child(+ Label::new(uri.to_string())+ .size(LabelSize::XSmall)+ .color(Color::Muted),+ )+ })+ .into_any_element()+ }+fn render_resource_link(&self,resource_link: &acp::ResourceLink,@@ -9762,28 +9812,10 @@ impl ThreadView {&self,entry_ix: usize,image: Arc<gpui::Image>,- dimensions: Option<gpui::Size<u32>>,location: Option<acp::ToolCallLocation>,card_layout: bool,cx: &Context<Self>,) -> AnyElement {- let format_name = match image.format() {- gpui::ImageFormat::Png => "PNG",- gpui::ImageFormat::Jpeg => "JPEG",- gpui::ImageFormat::Webp => "WebP",- gpui::ImageFormat::Gif => "GIF",- gpui::ImageFormat::Svg => "SVG",- gpui::ImageFormat::Bmp => "BMP",- gpui::ImageFormat::Tiff => "TIFF",- gpui::ImageFormat::Ico => "ICO",- gpui::ImageFormat::Pnm => "PNM",- };- let dimensions_label = if let Some(size) = dimensions {- format!("{}×{} {}", size.width, size.height, format_name)- } else {- format_name.into()- };-v_flex().gap_2().map(|this| {@@ -9796,27 +9828,17 @@ impl ThreadView {.border_color(self.tool_card_border_color(cx))}})- .child(- h_flex()- .w_full()- .justify_between()- .items_center()- .child(- Label::new(dimensions_label)- .size(LabelSize::XSmall)- .color(Color::Muted)- .buffer_font(cx),- )- .when_some(location, |this, _loc| {- this.child(- Button::new(("go-to-file", entry_ix), "Go to File")- .label_size(LabelSize::Small)- .on_click(cx.listener(move |this, _, window, cx| {- this.open_tool_call_location(entry_ix, 0, window, cx);- })),- )- }),- )+ .when_some(location, |this, _loc| {+ this.child(+ h_flex().w_full().justify_end().child(+ Button::new(("go-to-file", entry_ix), "Go to File")+ .label_size(LabelSize::Small)+ .on_click(cx.listener(move |this, _, window, cx| {+ this.open_tool_call_location(entry_ix, 0, window, cx);+ })),+ ),+ )+ }).child(img(image).max_w_96()@@ -9906,8 +9928,8 @@ impl ThreadView {let is_cancelled = matches!(tool_call.status, ToolCallStatus::Canceled)|| tool_call.content.iter().any(|c| match c {- ToolCallContent::ContentBlock(ContentBlock::Markdown { markdown }) => {- markdown.read(cx).source() == "User canceled"+ ToolCallContent::ContentBlock(block) => {+ block.text_content(cx) == Some("User canceled")}_ => false,});@@ -10284,14 +10306,12 @@ impl ThreadView {if matches!(status, ToolCallStatus::Failed) {tool_call.content.iter().find_map(|content| {if let ToolCallContent::ContentBlock(block) = content {- if let acp_thread::ContentBlock::Markdown { markdown } = block {- let source = markdown.read(cx).source().to_string();- if !source.is_empty() {- if source == "User canceled" {- return None;- } else {- return Some(SharedString::from(source));- }+ if let Some(source) = block.text_content(cx).filter(|source| !source.is_empty())+ {+ if source == "User canceled" {+ return None;+ } else {+ return Some(SharedString::from(source));}}}