modifies server init process to accommodate for different transport type

Author: dingfeli

crates/chat-cli/src/cli/chat/server_messenger.rs

@@ -44,6 +44,10 @@ pub enum UpdateEventMessage {
         result: Result<ListResourceTemplatesResult>,
         peer: Option<Peer<RoleClient>>,
     },
+    OauthLink {
+        server_name: String,
+        link: String,
+    },
     InitStart {
         server_name: String,
     },
@@ -146,6 +150,17 @@ impl Messenger for ServerMessenger {
             .map_err(|e| MessengerError::Custom(e.to_string()))?)
     }
 
+    async fn send_oauth_link(&self, link: String) -> MessengerResult {
+        Ok(self
+            .update_event_sender
+            .send(UpdateEventMessage::OauthLink {
+                server_name: self.server_name.clone(),
+                link,
+            })
+            .await
+            .map_err(|e| MessengerError::Custom(e.to_string()))?)
+    }
+
     async fn send_init_msg(&self) -> MessengerResult {
         Ok(self
             .update_event_sender

crates/chat-cli/src/cli/chat/tool_manager.rs

@@ -630,19 +630,25 @@ impl ToolManager {
                         let server_name_clone = server_name.clone();
                         tokio::spawn(async move {
                             match handle.await {
-                                Ok(Ok(client)) => match client.cancel().await {
-                                    Ok(_) => info!("Server {server_name_clone} evicted due to agent swap"),
-                                    Err(e) => error!("Server {server_name_clone} has failed to cancel: {e}"),
+                                Ok(Ok(client)) => {
+                                    let client = client.inner_service;
+                                    match client.cancel().await {
+                                        Ok(_) => info!("Server {server_name_clone} evicted due to agent swap"),
+                                        Err(e) => error!("Server {server_name_clone} has failed to cancel: {e}"),
+                                    }
                                 },
                                 Ok(Err(_)) | Err(_) => {
                                     error!("Server {server_name_clone} has failed to cancel");
                                 },
                             }
                         });
                     },
-                    InitializedMcpClient::Ready(running_service) => match running_service.cancel().await {
-                        Ok(_) => info!("Server {server_name} evicted due to agent swap"),
-                        Err(e) => error!("Server {server_name} has failed to cancel: {e}"),
+                    InitializedMcpClient::Ready(running_service) => {
+                        let client = running_service.inner_service;
+                        match client.cancel().await {
+                            Ok(_) => info!("Server {server_name} evicted due to agent swap"),
+                            Err(e) => error!("Server {server_name} has failed to cancel: {e}"),
+                        }
                     },
                 }
             }
@@ -1595,6 +1601,37 @@ fn spawn_orchestrator_task(
                 },
                 UpdateEventMessage::ListResourcesResult { .. } => {},
                 UpdateEventMessage::ResourceTemplatesListResult { .. } => {},
+                UpdateEventMessage::OauthLink { server_name, link } => {
+                    let mut buf_writer = BufWriter::new(&mut *record_temp_buf);
+                    let msg = eyre::eyre!(link);
+                    let _ = queue_oauth_message(server_name.as_str(), &msg, &mut buf_writer);
+                    let _ = buf_writer.flush();
+                    drop(buf_writer);
+                    let record_str = String::from_utf8_lossy(record_temp_buf).to_string();
+                    let record = LoadingRecord::Warn(record_str.clone());
+                    load_record
+                        .lock()
+                        .await
+                        .entry(server_name.clone())
+                        .and_modify(|load_record| {
+                            load_record.push(record.clone());
+                        })
+                        .or_insert(vec![record]);
+                    if let Some(sender) = &loading_status_sender {
+                        let msg = LoadingMsg::Warn {
+                            name: server_name.clone(),
+                            msg: eyre::eyre!("{}", record_str),
+                            time: "0.0".to_string(),
+                        };
+                        if let Err(e) = sender.send(msg).await {
+                            warn!(
+                                "Error sending update message to display task: {:?}\nAssume display task has completed",
+                                e
+                            );
+                            loading_status_sender.take();
+                        }
+                    }
+                },
                 UpdateEventMessage::InitStart { server_name, .. } => {
                     pending.write().await.insert(server_name.clone());
                     loading_servers.insert(server_name, std::time::Instant::now());
@@ -1876,6 +1913,21 @@ fn queue_failure_message(
     )?)
 }
 
+fn queue_oauth_message(name: &str, msg: &eyre::Report, output: &mut impl Write) -> eyre::Result<()> {
+    Ok(queue!(
+        output,
+        style::SetForegroundColor(style::Color::Yellow),
+        style::Print("⚠ "),
+        style::SetForegroundColor(style::Color::Blue),
+        style::Print(name),
+        style::ResetColor,
+        style::Print(" requires OAuth authentication. Please visit:\n"),
+        style::SetForegroundColor(style::Color::Cyan),
+        style::Print(msg),
+        style::ResetColor,
+    )?)
+}
+
 fn queue_warn_message(name: &str, msg: &eyre::Report, time: &str, output: &mut impl Write) -> eyre::Result<()> {
     Ok(queue!(
         output,

crates/chat-cli/src/cli/chat/tools/custom_tool.rs

@@ -28,9 +28,8 @@ use crate::util::MCP_SERVER_TOOL_DELIMITER;
 use crate::util::pattern_matching::matches_any_pattern;
 
 #[derive(Clone, Serialize, Deserialize, Debug, Eq, PartialEq, JsonSchema)]
+#[serde(rename_all = "camelCase")]
 pub enum TransportType {
-    /// Server-Sent Events transport for real-time communication
-    Sse,
     /// Standard input/output transport (default)
     Stdio,
     /// HTTP transport for web-based communication
@@ -48,6 +47,12 @@ pub struct CustomToolConfig {
     /// The type of transport the mcp server is expecting
     #[serde(default)]
     pub r#type: TransportType,
+    /// The URL endpoint for HTTP-based MCP servers
+    #[serde(default)]
+    pub url: String,
+    /// HTTP headers to include when communicating with HTTP-based MCP servers
+    #[serde(default)]
+    pub headers: HashMap<String, String>,
     /// The command string used to initialize the mcp server
     #[serde(default)]
     pub command: String,