Escape markdown in tools' ui_text (#27502)

Escape markdown in tools' `ui_text`

<img width="628" alt="Screenshot 2025-03-26 at 10 43 23 AM"
src="https://github.com/user-attachments/assets/bb694821-aae7-4ccf-a35a-a3317b0222d5"
/>


Release Notes:

- N/A

crates/assistant_tools/src/diagnostics_tool.rs

@@ -6,12 +6,9 @@ use language_model::LanguageModelRequestMessage;
 use project::Project;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use std::{
-    fmt::Write,
-    path::{Path, PathBuf},
-    sync::Arc,
-};
+use std::{fmt::Write, path::Path, sync::Arc};
 use ui::IconName;
+use util::markdown::MarkdownString;
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct DiagnosticsToolInput {
@@ -28,7 +25,7 @@ pub struct DiagnosticsToolInput {
     ///
     /// If you wanna access diagnostics for `dolor.txt` in `ipsum`, you should use the path `ipsum/dolor.txt`.
     /// </example>
-    pub path: Option<PathBuf>,
+    pub path: Option<String>,
 }
 
 pub struct DiagnosticsTool;
@@ -58,9 +55,12 @@ impl Tool for DiagnosticsTool {
     fn ui_text(&self, input: &serde_json::Value) -> String {
         if let Some(path) = serde_json::from_value::<DiagnosticsToolInput>(input.clone())
             .ok()
-            .and_then(|input| input.path)
+            .and_then(|input| match input.path {
+                Some(path) if !path.is_empty() => Some(MarkdownString::escape(&path)),
+                _ => None,
+            })
         {
-            format!("Check diagnostics for “`{}`”", path.display())
+            format!("Check diagnostics for `{path}`")
         } else {
             "Check project diagnostics".to_string()
         }
@@ -74,75 +74,77 @@ impl Tool for DiagnosticsTool {
         _action_log: Entity<ActionLog>,
         cx: &mut App,
     ) -> Task<Result<String>> {
-        if let Some(path) = serde_json::from_value::<DiagnosticsToolInput>(input)
+        match serde_json::from_value::<DiagnosticsToolInput>(input)
             .ok()
             .and_then(|input| input.path)
         {
-            let Some(project_path) = project.read(cx).find_project_path(&path, cx) else {
-                return Task::ready(Err(anyhow!(
-                    "Could not find path {} in project",
-                    path.display()
-                )));
-            };
-            let buffer = project.update(cx, |project, cx| project.open_buffer(project_path, cx));
+            Some(path) if !path.is_empty() => {
+                let Some(project_path) = project.read(cx).find_project_path(&path, cx) else {
+                    return Task::ready(Err(anyhow!("Could not find path {path} in project",)));
+                };
 
-            cx.spawn(async move |cx| {
-                let mut output = String::new();
-                let buffer = buffer.await?;
-                let snapshot = buffer.read_with(cx, |buffer, _cx| buffer.snapshot())?;
+                let buffer =
+                    project.update(cx, |project, cx| project.open_buffer(project_path, cx));
 
-                for (_, group) in snapshot.diagnostic_groups(None) {
-                    let entry = &group.entries[group.primary_ix];
-                    let range = entry.range.to_point(&snapshot);
-                    let severity = match entry.diagnostic.severity {
-                        DiagnosticSeverity::ERROR => "error",
-                        DiagnosticSeverity::WARNING => "warning",
-                        _ => continue,
-                    };
+                cx.spawn(async move |cx| {
+                    let mut output = String::new();
+                    let buffer = buffer.await?;
+                    let snapshot = buffer.read_with(cx, |buffer, _cx| buffer.snapshot())?;
 
-                    writeln!(
-                        output,
-                        "{} at line {}: {}",
-                        severity,
-                        range.start.row + 1,
-                        entry.diagnostic.message
-                    )?;
-                }
+                    for (_, group) in snapshot.diagnostic_groups(None) {
+                        let entry = &group.entries[group.primary_ix];
+                        let range = entry.range.to_point(&snapshot);
+                        let severity = match entry.diagnostic.severity {
+                            DiagnosticSeverity::ERROR => "error",
+                            DiagnosticSeverity::WARNING => "warning",
+                            _ => continue,
+                        };
 
-                if output.is_empty() {
-                    Ok("File doesn't have errors or warnings!".to_string())
-                } else {
-                    Ok(output)
-                }
-            })
-        } else {
-            let project = project.read(cx);
-            let mut output = String::new();
-            let mut has_diagnostics = false;
+                        writeln!(
+                            output,
+                            "{} at line {}: {}",
+                            severity,
+                            range.start.row + 1,
+                            entry.diagnostic.message
+                        )?;
+                    }
 
-            for (project_path, _, summary) in project.diagnostic_summaries(true, cx) {
-                if summary.error_count > 0 || summary.warning_count > 0 {
-                    let Some(worktree) = project.worktree_for_id(project_path.worktree_id, cx)
-                    else {
-                        continue;
-                    };
-
-                    has_diagnostics = true;
-                    output.push_str(&format!(
-                        "{}: {} error(s), {} warning(s)\n",
-                        Path::new(worktree.read(cx).root_name())
-                            .join(project_path.path)
-                            .display(),
-                        summary.error_count,
-                        summary.warning_count
-                    ));
-                }
+                    if output.is_empty() {
+                        Ok("File doesn't have errors or warnings!".to_string())
+                    } else {
+                        Ok(output)
+                    }
+                })
             }
+            _ => {
+                let project = project.read(cx);
+                let mut output = String::new();
+                let mut has_diagnostics = false;
 
-            if has_diagnostics {
-                Task::ready(Ok(output))
-            } else {
-                Task::ready(Ok("No errors or warnings found in the project.".to_string()))
+                for (project_path, _, summary) in project.diagnostic_summaries(true, cx) {
+                    if summary.error_count > 0 || summary.warning_count > 0 {
+                        let Some(worktree) = project.worktree_for_id(project_path.worktree_id, cx)
+                        else {
+                            continue;
+                        };
+
+                        has_diagnostics = true;
+                        output.push_str(&format!(
+                            "{}: {} error(s), {} warning(s)\n",
+                            Path::new(worktree.read(cx).root_name())
+                                .join(project_path.path)
+                                .display(),
+                            summary.error_count,
+                            summary.warning_count
+                        ));
+                    }
+                }
+
+                if has_diagnostics {
+                    Task::ready(Ok(output))
+                } else {
+                    Task::ready(Ok("No errors or warnings found in the project.".to_string()))
+                }
             }
         }
     }