use std::sync::Arc; use std::sync::Weak; use anyhow::Context; use anyhow::Result; use codex_protocol::mcp::Resource; use codex_protocol::mcp::ResourceContent; use rmcp::model::PaginatedRequestParams; use rmcp::model::ReadResourceRequestParams; use crate::McpRuntime; use crate::connection_manager::McpConnectionSet; /// One page of resources returned by an MCP server. #[derive(Clone, Debug, PartialEq)] pub struct McpResourcePage { /// Resources advertised on this page. pub resources: Vec, /// Opaque cursor to supply when requesting the next page. pub next_cursor: Option, } /// Contents returned after reading one MCP resource. #[derive(Clone, Debug, PartialEq)] pub struct McpResourceReadResult { /// Text or blob content returned for the requested resource. pub contents: Vec, } /// Access to MCP resources through the latest runtime. #[derive(Clone)] pub struct McpResourceClient { runtime: Arc, } /// Opaque identity for the connection set currently used by an MCP resource client. #[derive(Clone)] pub struct McpResourceClientCacheKey(Weak); impl PartialEq for McpResourceClientCacheKey { fn eq(&self, other: &Self) -> bool { self.0.ptr_eq(&other.0) } } impl Eq for McpResourceClientCacheKey {} impl std::fmt::Debug for McpResourceClient { fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { formatter .debug_struct("McpResourceClient") .finish_non_exhaustive() } } impl McpResourceClient { /// Creates a resource client that follows the thread's latest published runtime. pub fn new(runtime: Arc) -> Self { Self { runtime } } /// Returns the identity of the connection set used by this client. pub fn cache_key(&self) -> McpResourceClientCacheKey { McpResourceClientCacheKey(Arc::downgrade(&self.runtime.latest_connections())) } /// Returns whether this client can address the named server. /// /// This does not wait for server startup. pub async fn has_server(&self, server: &str) -> bool { self.runtime.latest_connections().contains_server(server) } /// Lists one resource page from the named server. pub async fn list_resources( &self, server: &str, cursor: Option, ) -> Result { let params = cursor.map(|cursor| PaginatedRequestParams::default().with_cursor(Some(cursor))); let result = self .runtime .latest_connections() .list_resources(server, params) .await?; let resources = result .resources .into_iter() .map(resource_from_rmcp) .collect::>>()?; Ok(McpResourcePage { resources, next_cursor: result.next_cursor, }) } /// Reads one resource from the named server. pub async fn read_resource(&self, server: &str, uri: &str) -> Result { let params = ReadResourceRequestParams::new(uri.to_string()); let result = self .runtime .latest_connections() .read_resource(server, params) .await?; let contents = result .contents .into_iter() .map(resource_content_from_rmcp) .collect::>>()?; Ok(McpResourceReadResult { contents }) } } fn resource_from_rmcp(resource: rmcp::model::Resource) -> Result { let value = serde_json::to_value(resource).context("failed to serialize MCP resource")?; Resource::from_mcp_value(value).context("failed to convert MCP resource") } fn resource_content_from_rmcp(content: rmcp::model::ResourceContents) -> Result { let value = serde_json::to_value(content).context("failed to serialize MCP resource content")?; serde_json::from_value(value).context("failed to convert MCP resource content") }