agent: Add websearch tool (#28621)

Staff only for now. We'll work on making this usable for non zed.dev
users later

Release Notes:

- N/A

---------

Co-authored-by: Antonio Scandurra <me@as-cii.com>
Co-authored-by: Danilo Leal <daniloleal09@gmail.com>
Co-authored-by: Marshall Bowers <git@maxdeviant.com>

crates/assistant_tool/src/assistant_tool.rs

@@ -9,6 +9,10 @@ use std::fmt::Formatter;
 use std::sync::Arc;
 
 use anyhow::Result;
+use gpui::AnyElement;
+use gpui::Context;
+use gpui::IntoElement;
+use gpui::Window;
 use gpui::{App, Entity, SharedString, Task};
 use icons::IconName;
 use language_model::LanguageModelRequestMessage;
@@ -24,16 +28,87 @@ pub fn init(cx: &mut App) {
     ToolRegistry::default_global(cx);
 }
 
-/// The result of running a tool
+#[derive(Debug, Clone)]
+pub enum ToolUseStatus {
+    NeedsConfirmation,
+    Pending,
+    Running,
+    Finished(SharedString),
+    Error(SharedString),
+}
+
+impl ToolUseStatus {
+    pub fn text(&self) -> SharedString {
+        match self {
+            ToolUseStatus::NeedsConfirmation => "".into(),
+            ToolUseStatus::Pending => "".into(),
+            ToolUseStatus::Running => "".into(),
+            ToolUseStatus::Finished(out) => out.clone(),
+            ToolUseStatus::Error(out) => out.clone(),
+        }
+    }
+}
+
+/// The result of running a tool, containing both the asynchronous output
+/// and an optional card view that can be rendered immediately.
 pub struct ToolResult {
     /// The asynchronous task that will eventually resolve to the tool's output
     pub output: Task<Result<String>>,
+    /// An optional view to present the output of the tool.
+    pub card: Option<AnyToolCard>,
+}
+
+pub trait ToolCard: 'static + Sized {
+    fn render(
+        &mut self,
+        status: &ToolUseStatus,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> impl IntoElement;
+}
+
+#[derive(Clone)]
+pub struct AnyToolCard {
+    entity: gpui::AnyEntity,
+    render: fn(
+        entity: gpui::AnyEntity,
+        status: &ToolUseStatus,
+        window: &mut Window,
+        cx: &mut App,
+    ) -> AnyElement,
+}
+
+impl<T: ToolCard> From<Entity<T>> for AnyToolCard {
+    fn from(entity: Entity<T>) -> Self {
+        fn downcast_render<T: ToolCard>(
+            entity: gpui::AnyEntity,
+            status: &ToolUseStatus,
+            window: &mut Window,
+            cx: &mut App,
+        ) -> AnyElement {
+            let entity = entity.downcast::<T>().unwrap();
+            entity.update(cx, |entity, cx| {
+                entity.render(status, window, cx).into_any_element()
+            })
+        }
+
+        Self {
+            entity: entity.into(),
+            render: downcast_render::<T>,
+        }
+    }
+}
+
+impl AnyToolCard {
+    pub fn render(&self, status: &ToolUseStatus, window: &mut Window, cx: &mut App) -> AnyElement {
+        (self.render)(self.entity.clone(), status, window, cx)
+    }
 }
 
 impl From<Task<Result<String>>> for ToolResult {
-    /// Convert from a task to a ToolResult
+    /// Convert from a task to a ToolResult with no card
     fn from(output: Task<Result<String>>) -> Self {
-        Self { output }
+        Self { output, card: None }
     }
 }