Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Add MIME-filtered resource listing for Codex Apps (#44548)

Alex Zamoshchin94697375cb9d
diff --git a/codex-rs/codex-mcp/src/lib.rs b/codex-rs/codex-mcp/src/lib.rs
index 1d8f90105d..af66f91394 100644
--- a/codex-rs/codex-mcp/src/lib.rs
+++ b/codex-rs/codex-mcp/src/lib.rs
@@ -9,6 +9,7 @@ pub use elicitation::ElicitationReviewRequest;
pub use elicitation::ElicitationReviewer;
pub use elicitation::ElicitationReviewerHandle;
pub use event_stream::McpEventStreamOpener;
+pub use resource_client::CodexAppsResourceListParams;
pub use resource_client::McpEventCatalogSnapshot;
pub use resource_client::McpEventDefinition;
pub use resource_client::McpEventNotification;
diff --git a/codex-rs/codex-mcp/src/resource_client.rs b/codex-rs/codex-mcp/src/resource_client.rs
index 43d82a8378..3c13695c73 100644
--- a/codex-rs/codex-mcp/src/resource_client.rs
+++ b/codex-rs/codex-mcp/src/resource_client.rs
@@ -15,6 +15,7 @@ use rmcp::model::ReadResourceRequestParams;
use rmcp::model::ServerResult;
use rmcp::service::ServiceError;
use serde::Deserialize;
+use serde::Serialize;
use serde_json::Map;
use serde_json::Value;
use serde_json::json;
@@ -35,6 +36,18 @@ pub struct McpResourcePage {
pub next_cursor: Option<String>,
}
+/// Parameters for one Codex Apps resource page.
+///
+/// Keep `mime_type` when requesting a continuation page: the server applies
+/// the filter to each request separately.
+#[derive(Clone, Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CodexAppsResourceListParams {
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub cursor: Option<String>,
+ pub mime_type: String,
+}
+
/// Contents returned after reading one MCP resource.
#[derive(Clone, Debug, PartialEq)]
pub struct McpResourceReadResult {
@@ -237,6 +250,40 @@ impl McpResourceClient {
})
}
+ /// Lists one Codex Apps resource page using plugin-service's top-level `mimeType` parameter.
+ pub async fn list_codex_apps_resources(
+ &self,
+ params: CodexAppsResourceListParams,
+ ) -> Result<McpResourcePage> {
+ let params = serde_json::to_value(params)
+ .context("failed to serialize Codex Apps resource params")?;
+ let connections = self.runtime.latest_host_owned_codex_apps_connections()?;
+ let (managed, timeout) = connections
+ .client_by_name(CODEX_APPS_MCP_SERVER_NAME)
+ .await?;
+ let result = managed
+ .client
+ .send_custom_request_with_timeout("resources/list", Some(params), timeout)
+ .await
+ .context("resources/list failed for `codex_apps`")?;
+ let result = match result {
+ ServerResult::ListResourcesResult(result) => result,
+ ServerResult::CustomResult(result) => result
+ .result_as::<rmcp::model::ListResourcesResult>()
+ .context("resources/list returned invalid resources")?,
+ _ => return Err(anyhow!("resources/list returned an unexpected MCP result")),
+ };
+ let resources = result
+ .resources
+ .into_iter()
+ .map(resource_from_rmcp)
+ .collect::<Result<Vec<_>>>()?;
+ 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<McpResourceReadResult> {
let params = ReadResourceRequestParams::new(uri.to_string());
diff --git a/codex-rs/codex-mcp/src/runtime.rs b/codex-rs/codex-mcp/src/runtime.rs
index 2ad549d5e7..09064ebc9a 100644
--- a/codex-rs/codex-mcp/src/runtime.rs
+++ b/codex-rs/codex-mcp/src/runtime.rs
@@ -118,6 +118,25 @@ struct PublishedMcpRuntime {
cached_binding: Mutex<Option<CachedMcpBinding>>,
}
+fn ensure_host_owned_apps_registration(
+ current: &PublishedMcpRuntime,
+ server: &str,
+) -> anyhow::Result<()> {
+ if !current
+ .config
+ .as_ref()
+ .and_then(|config| config.mcp_server_catalog.server(server))
+ .is_some_and(|registration| {
+ registration
+ .source()
+ .is_host_owned_apps(server, registration.config())
+ })
+ {
+ anyhow::bail!("MCP server '{server}' is not registered by the hosted runtime");
+ }
+ Ok(())
+}
+
struct CachedMcpBinding {
catalog_revisions: HashMap<String, BindingCatalogRevision>,
binding: Arc<McpBinding>,
@@ -626,6 +645,14 @@ impl McpRuntime {
Arc::clone(&self.current.load().connections)
}
+ pub(crate) fn latest_host_owned_codex_apps_connections(
+ &self,
+ ) -> anyhow::Result<Arc<McpConnectionSet>> {
+ let current = self.current.load();
+ ensure_host_owned_apps_registration(&current, CODEX_APPS_MCP_SERVER_NAME)?;
+ Ok(Arc::clone(&current.connections))
+ }
+
pub(crate) fn latest_connections_for_event_server(
&self,
server: &str,
@@ -638,18 +665,8 @@ impl McpRuntime {
.cancel_event_streams_on_server_removal
.subscribe();
let current = self.current.load();
- if server == CODEX_APPS_MCP_SERVER_NAME
- && !current
- .config
- .as_ref()
- .and_then(|config| config.mcp_server_catalog.server(server))
- .is_some_and(|registration| {
- registration
- .source()
- .is_host_owned_apps(server, registration.config())
- })
- {
- anyhow::bail!("MCP server '{server}' is not registered by the hosted runtime");
+ if server == CODEX_APPS_MCP_SERVER_NAME {
+ ensure_host_owned_apps_registration(&current, server)?;
}
Ok((
Arc::clone(&current.connections),
diff --git a/codex-rs/core/tests/suite/mcp_tool_exposure.rs b/codex-rs/core/tests/suite/mcp_tool_exposure.rs
index b554904652..ba63b5565a 100644
--- a/codex-rs/core/tests/suite/mcp_tool_exposure.rs
+++ b/codex-rs/core/tests/suite/mcp_tool_exposure.rs
@@ -14,6 +14,7 @@ use codex_extension_api::ThreadStartInput;
use codex_features::Feature;
use codex_history::RolloutItem;
use codex_mcp::CODEX_APPS_MCP_SERVER_NAME;
+use codex_mcp::CodexAppsResourceListParams;
use codex_mcp::McpResourceClient;
use codex_protocol::capabilities::CapabilityRootLocation;
use codex_protocol::capabilities::SelectedCapabilityRoot;
@@ -659,6 +660,160 @@ async fn timeout_refresh_replaces_pending_startup_and_reuses_ready_connection()
Ok(())
}
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn codex_apps_resource_filter_sends_mime_type_on_each_page() -> Result<()> {
+ skip_if_no_network!(Ok(()));
+
+ let server = responses::start_mock_server().await;
+ let apps_server = AppsTestServer::mount_searchable(&server).await?;
+ let first_resource = json!({
+ "uri": "plugin://first",
+ "name": "first",
+ "mimeType": "mcp/plugin",
+ });
+ let second_resource = json!({
+ "uri": "plugin://second",
+ "name": "second",
+ "mimeType": "mcp/plugin",
+ });
+ let first_response_resource = first_resource.clone();
+ let second_response_resource = second_resource.clone();
+ Mock::given(method("POST"))
+ .and(path_regex("^/api/codex/ps/mcp/?$"))
+ .and(body_partial_json(json!({ "method": "resources/list" })))
+ .respond_with(move |request: &Request| {
+ let body: Value = serde_json::from_slice(&request.body).expect("valid MCP request");
+ let result = match body["params"]["cursor"].as_str() {
+ None => json!({
+ "resources": [first_response_resource],
+ "nextCursor": "next-page",
+ }),
+ Some("next-page") => json!({ "resources": [second_response_resource] }),
+ Some(cursor) => panic!("unexpected cursor: {cursor}"),
+ };
+ ResponseTemplate::new(200).set_body_json(json!({
+ "jsonrpc": "2.0",
+ "id": body["id"],
+ "result": result,
+ }))
+ })
+ .with_priority(1)
+ .mount(&server)
+ .await;
+
+ let captured_client = Arc::new(Mutex::new(None));
+ let mut extensions = ExtensionRegistryBuilder::<Config>::new();
+ extensions.thread_lifecycle_contributor(Arc::new(McpResourceClientCapture {
+ client: Arc::clone(&captured_client),
+ }));
+ let test = search_capable_apps_builder(apps_server.chatgpt_base_url)
+ .with_extensions(Arc::new(extensions.build()))
+ .build_with_auto_env(&server)
+ .await?;
+ wait_for_mcp_server(&test.codex, CODEX_APPS_MCP_SERVER_NAME).await?;
+ let client = captured_client
+ .lock()
+ .expect("capture lock should not be poisoned")
+ .clone()
+ .expect("thread start should capture the MCP resource client");
+ let expected_pages = [
+ codex_mcp::McpResourcePage {
+ resources: vec![serde_json::from_value(first_resource)?],
+ next_cursor: Some("next-page".to_string()),
+ },
+ codex_mcp::McpResourcePage {
+ resources: vec![serde_json::from_value(second_resource)?],
+ next_cursor: None,
+ },
+ ];
+
+ for (cursor, expected_page) in [
+ (None, &expected_pages[0]),
+ (Some("next-page".to_string()), &expected_pages[1]),
+ ] {
+ let page = client
+ .list_codex_apps_resources(CodexAppsResourceListParams {
+ cursor,
+ mime_type: "mcp/plugin".to_string(),
+ })
+ .await?;
+ assert_eq!(page, *expected_page);
+ }
+
+ let requests = server.received_requests().await.expect("recorded requests");
+ let params = requests
+ .iter()
+ .filter_map(|request| serde_json::from_slice::<Value>(&request.body).ok())
+ .filter(|body| body["method"] == "resources/list")
+ .map(|body| {
+ let mut params = body["params"].as_object().cloned().unwrap_or_default();
+ // The transport adds progress metadata independently of the filter.
+ params.remove("_meta");
+ Value::Object(params)
+ })
+ .collect::<Vec<_>>();
+ assert_eq!(
+ params,
+ vec![
+ json!({ "mimeType": "mcp/plugin" }),
+ json!({ "cursor": "next-page", "mimeType": "mcp/plugin" }),
+ ]
+ );
+ test.codex.shutdown_and_wait().await?;
+ Ok(())
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn codex_apps_resource_filter_rejects_extension_name_collision() -> Result<()> {
+ skip_if_no_network!(Ok(()));
+
+ let server = responses::start_mock_server().await;
+ let apps_server = AppsTestServer::mount_searchable(&server).await?;
+ let captured_client = Arc::new(Mutex::new(None));
+ let mut extensions = ExtensionRegistryBuilder::<Config>::new();
+ extensions.mcp_server_contributor(Arc::new(AppsMcpServerContributor {
+ id: "test-extension",
+ url: format!("{}/api/codex/ps/mcp", apps_server.chatgpt_base_url),
+ root_resolved: None,
+ }));
+ extensions.thread_lifecycle_contributor(Arc::new(McpResourceClientCapture {
+ client: Arc::clone(&captured_client),
+ }));
+ let test = search_capable_apps_builder(apps_server.chatgpt_base_url)
+ .with_extensions(Arc::new(extensions.build()))
+ .build_with_auto_env(&server)
+ .await?;
+ wait_for_mcp_server(&test.codex, CODEX_APPS_MCP_SERVER_NAME).await?;
+ let client = captured_client
+ .lock()
+ .expect("capture lock should not be poisoned")
+ .clone()
+ .expect("thread start should capture the MCP resource client");
+ assert!(client.has_server(CODEX_APPS_MCP_SERVER_NAME).await);
+
+ let error = client
+ .list_codex_apps_resources(CodexAppsResourceListParams {
+ cursor: None,
+ mime_type: "mcp/plugin".to_string(),
+ })
+ .await
+ .expect_err("an extension named codex_apps must not inherit the Apps resource filter");
+ assert_eq!(
+ error.to_string(),
+ "MCP server 'codex_apps' is not registered by the hosted runtime"
+ );
+ let requests = server.received_requests().await.expect("recorded requests");
+ assert!(
+ !requests.iter().any(|request| {
+ serde_json::from_slice::<Value>(&request.body)
+ .is_ok_and(|body| body["method"] == "resources/list")
+ }),
+ "an extension named codex_apps must not receive filtered resource requests"
+ );
+ test.codex.shutdown_and_wait().await?;
+ Ok(())
+}
+
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn out_of_band_resource_read_reconciles_the_published_mcp_runtime() -> Result<()> {
let server = responses::start_mock_server().await;