Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Deduplicate MCP resource list handling (#36734)

jifd6407d735942
diff --git a/codex-rs/core/src/tools/handlers/mcp_resource.rs b/codex-rs/core/src/tools/handlers/mcp_resource.rs
index 0cd5857302..deb7491e75 100644
--- a/codex-rs/core/src/tools/handlers/mcp_resource.rs
+++ b/codex-rs/core/src/tools/handlers/mcp_resource.rs
@@ -15,6 +15,7 @@ use codex_protocol::protocol::TruncationPolicy;
use codex_utils_output_truncation::truncate_text;
use rmcp::model::ListResourceTemplatesResult;
use rmcp::model::ListResourcesResult;
+use rmcp::model::PaginatedRequestParams;
use rmcp::model::ReadResourceResult;
use rmcp::model::Resource;
use rmcp::model::ResourceTemplate;
@@ -56,22 +57,41 @@ fn ensure_model_can_access_mcp_server(
}
}
-#[derive(Debug, Deserialize, Default)]
-struct ListResourcesArgs {
- /// Lists all resources from all servers if not specified.
+#[derive(Debug, Deserialize, Default, PartialEq, Eq)]
+struct ListResourceArgs {
#[serde(default)]
server: Option<String>,
#[serde(default)]
cursor: Option<String>,
}
-#[derive(Debug, Deserialize, Default)]
-struct ListResourceTemplatesArgs {
- /// Lists all resource templates from all servers if not specified.
- #[serde(default)]
- server: Option<String>,
- #[serde(default)]
- cursor: Option<String>,
+impl ListResourceArgs {
+ fn normalized(self) -> Self {
+ Self {
+ server: normalize_optional_string(self.server),
+ cursor: normalize_optional_string(self.cursor),
+ }
+ }
+
+ fn target(
+ &self,
+ turn: &TurnContext,
+ ) -> Result<Option<(String, Option<PaginatedRequestParams>)>, FunctionCallError> {
+ match &self.server {
+ Some(server) => {
+ ensure_model_can_access_mcp_server(turn, server)?;
+ let params = self
+ .cursor
+ .clone()
+ .map(|cursor| PaginatedRequestParams::default().with_cursor(Some(cursor)));
+ Ok(Some((server.clone(), params)))
+ }
+ None if self.cursor.is_some() => Err(FunctionCallError::RespondToModel(
+ "cursor can only be used when a server is specified".to_string(),
+ )),
+ None => Ok(None),
+ }
+ }
}
#[derive(Debug, Deserialize)]
@@ -81,28 +101,31 @@ struct ReadResourceArgs {
}
#[derive(Debug, Serialize)]
-struct ResourceWithServer {
+struct ResourceWithServer<T> {
server: String,
#[serde(flatten)]
- resource: Resource,
+ resource: T,
}
-impl ResourceWithServer {
- fn new(server: String, resource: Resource) -> Self {
+impl<T> ResourceWithServer<T> {
+ fn new(server: String, resource: T) -> Self {
Self { server, resource }
}
-}
-#[derive(Debug, Serialize)]
-struct ResourceTemplateWithServer {
- server: String,
- #[serde(flatten)]
- template: ResourceTemplate,
-}
+ fn from_server(server: &str, resources: Vec<T>) -> Vec<Self> {
+ resources
+ .into_iter()
+ .map(|resource| Self::new(server.to_string(), resource))
+ .collect()
+ }
-impl ResourceTemplateWithServer {
- fn new(server: String, template: ResourceTemplate) -> Self {
- Self { server, template }
+ fn from_all_servers(resources_by_server: HashMap<String, Vec<T>>) -> Vec<Self> {
+ let mut entries: Vec<_> = resources_by_server.into_iter().collect();
+ entries.sort_by(|(left, _), (right, _)| left.cmp(right));
+ entries
+ .into_iter()
+ .flat_map(|(server, resources)| Self::from_server(&server, resources))
+ .collect()
}
}
@@ -111,39 +134,24 @@ impl ResourceTemplateWithServer {
struct ListResourcesPayload {
#[serde(skip_serializing_if = "Option::is_none")]
server: Option<String>,
- resources: Vec<ResourceWithServer>,
+ resources: Vec<ResourceWithServer<Resource>>,
#[serde(skip_serializing_if = "Option::is_none")]
next_cursor: Option<String>,
}
impl ListResourcesPayload {
fn from_single_server(server: String, result: ListResourcesResult) -> Self {
- let resources = result
- .resources
- .into_iter()
- .map(|resource| ResourceWithServer::new(server.clone(), resource))
- .collect();
Self {
+ resources: ResourceWithServer::from_server(&server, result.resources),
server: Some(server),
- resources,
next_cursor: result.next_cursor,
}
}
fn from_all_servers(resources_by_server: HashMap<String, Vec<Resource>>) -> Self {
- let mut entries: Vec<(String, Vec<Resource>)> = resources_by_server.into_iter().collect();
- entries.sort_by(|a, b| a.0.cmp(&b.0));
-
- let mut resources = Vec::new();
- for (server, server_resources) in entries {
- for resource in server_resources {
- resources.push(ResourceWithServer::new(server.clone(), resource));
- }
- }
-
Self {
server: None,
- resources,
+ resources: ResourceWithServer::from_all_servers(resources_by_server),
next_cursor: None,
}
}
@@ -154,40 +162,24 @@ impl ListResourcesPayload {
struct ListResourceTemplatesPayload {
#[serde(skip_serializing_if = "Option::is_none")]
server: Option<String>,
- resource_templates: Vec<ResourceTemplateWithServer>,
+ resource_templates: Vec<ResourceWithServer<ResourceTemplate>>,
#[serde(skip_serializing_if = "Option::is_none")]
next_cursor: Option<String>,
}
impl ListResourceTemplatesPayload {
fn from_single_server(server: String, result: ListResourceTemplatesResult) -> Self {
- let resource_templates = result
- .resource_templates
- .into_iter()
- .map(|template| ResourceTemplateWithServer::new(server.clone(), template))
- .collect();
Self {
+ resource_templates: ResourceWithServer::from_server(&server, result.resource_templates),
server: Some(server),
- resource_templates,
next_cursor: result.next_cursor,
}
}
fn from_all_servers(templates_by_server: HashMap<String, Vec<ResourceTemplate>>) -> Self {
- let mut entries: Vec<(String, Vec<ResourceTemplate>)> =
- templates_by_server.into_iter().collect();
- entries.sort_by(|a, b| a.0.cmp(&b.0));
-
- let mut resource_templates = Vec::new();
- for (server, server_templates) in entries {
- for template in server_templates {
- resource_templates.push(ResourceTemplateWithServer::new(server.clone(), template));
- }
- }
-
Self {
server: None,
- resource_templates,
+ resource_templates: ResourceWithServer::from_all_servers(templates_by_server),
next_cursor: None,
}
}
diff --git a/codex-rs/core/src/tools/handlers/mcp_resource/list_mcp_resource_templates.rs b/codex-rs/core/src/tools/handlers/mcp_resource/list_mcp_resource_templates.rs
index 94b0132376..a988038dec 100644
--- a/codex-rs/core/src/tools/handlers/mcp_resource/list_mcp_resource_templates.rs
+++ b/codex-rs/core/src/tools/handlers/mcp_resource/list_mcp_resource_templates.rs
@@ -8,13 +8,9 @@ use codex_protocol::protocol::McpInvocation;
use codex_tools::ToolName;
use codex_tools::ToolSpec;
-use rmcp::model::PaginatedRequestParams;
-
-use super::ListResourceTemplatesArgs;
+use super::ListResourceArgs;
use super::ListResourceTemplatesPayload;
-use super::ensure_model_can_access_mcp_server;
use super::model_can_access_mcp_server;
-use super::normalize_optional_string;
use super::parse_args_with_default;
use super::parse_arguments;
use super::run_resource_operation;
@@ -64,23 +60,17 @@ impl ListMcpResourceTemplatesHandler {
};
let arguments = parse_arguments(arguments.as_str())?;
- let args: ListResourceTemplatesArgs = parse_args_with_default(arguments.clone())?;
- let ListResourceTemplatesArgs { server, cursor } = args;
- let server = normalize_optional_string(server);
- let cursor = normalize_optional_string(cursor);
+ let args: ListResourceArgs = parse_args_with_default(arguments.clone())?;
+ let args = args.normalized();
let invocation = McpInvocation {
- server: server.clone().unwrap_or_else(|| "codex".to_string()),
+ server: args.server.clone().unwrap_or_else(|| "codex".to_string()),
tool: "list_mcp_resource_templates".to_string(),
arguments: arguments.clone(),
};
run_resource_operation(&session, turn.as_ref(), &call_id, invocation, async {
- if let Some(server_name) = server.clone() {
- ensure_model_can_access_mcp_server(turn.as_ref(), &server_name)?;
- let params = cursor
- .clone()
- .map(|value| PaginatedRequestParams::default().with_cursor(Some(value)));
+ if let Some((server_name, params)) = args.target(turn.as_ref())? {
let result = mcp
.list_resource_templates(&server_name, params)
.await
@@ -94,12 +84,6 @@ impl ListMcpResourceTemplatesHandler {
result,
))
} else {
- if cursor.is_some() {
- return Err(FunctionCallError::RespondToModel(
- "cursor can only be used when a server is specified".to_string(),
- ));
- }
-
let templates = mcp
.list_all_resource_templates(|server_name| {
model_can_access_mcp_server(turn.as_ref(), server_name)
diff --git a/codex-rs/core/src/tools/handlers/mcp_resource/list_mcp_resources.rs b/codex-rs/core/src/tools/handlers/mcp_resource/list_mcp_resources.rs
index a966fbf4d2..d0d0d0f564 100644
--- a/codex-rs/core/src/tools/handlers/mcp_resource/list_mcp_resources.rs
+++ b/codex-rs/core/src/tools/handlers/mcp_resource/list_mcp_resources.rs
@@ -8,13 +8,9 @@ use codex_protocol::protocol::McpInvocation;
use codex_tools::ToolName;
use codex_tools::ToolSpec;
-use rmcp::model::PaginatedRequestParams;
-
-use super::ListResourcesArgs;
+use super::ListResourceArgs;
use super::ListResourcesPayload;
-use super::ensure_model_can_access_mcp_server;
use super::model_can_access_mcp_server;
-use super::normalize_optional_string;
use super::parse_args_with_default;
use super::parse_arguments;
use super::run_resource_operation;
@@ -64,23 +60,17 @@ impl ListMcpResourcesHandler {
};
let arguments = parse_arguments(arguments.as_str())?;
- let args: ListResourcesArgs = parse_args_with_default(arguments.clone())?;
- let ListResourcesArgs { server, cursor } = args;
- let server = normalize_optional_string(server);
- let cursor = normalize_optional_string(cursor);
+ let args: ListResourceArgs = parse_args_with_default(arguments.clone())?;
+ let args = args.normalized();
let invocation = McpInvocation {
- server: server.clone().unwrap_or_else(|| "codex".to_string()),
+ server: args.server.clone().unwrap_or_else(|| "codex".to_string()),
tool: "list_mcp_resources".to_string(),
arguments: arguments.clone(),
};
run_resource_operation(&session, turn.as_ref(), &call_id, invocation, async {
- if let Some(server_name) = server.clone() {
- ensure_model_can_access_mcp_server(turn.as_ref(), &server_name)?;
- let params = cursor
- .clone()
- .map(|value| PaginatedRequestParams::default().with_cursor(Some(value)));
+ if let Some((server_name, params)) = args.target(turn.as_ref())? {
let result = mcp
.list_resources(&server_name, params)
.await
@@ -92,12 +82,6 @@ impl ListMcpResourcesHandler {
result,
))
} else {
- if cursor.is_some() {
- return Err(FunctionCallError::RespondToModel(
- "cursor can only be used when a server is specified".to_string(),
- ));
- }
-
let resources = mcp
.list_all_resources(|server_name| {
model_can_access_mcp_server(turn.as_ref(), server_name)
diff --git a/codex-rs/core/src/tools/handlers/mcp_resource_tests.rs b/codex-rs/core/src/tools/handlers/mcp_resource_tests.rs
index 1155060d7c..7f58175206 100644
--- a/codex-rs/core/src/tools/handlers/mcp_resource_tests.rs
+++ b/codex-rs/core/src/tools/handlers/mcp_resource_tests.rs
@@ -88,9 +88,26 @@ fn parse_arguments_handles_empty_and_json() {
assert_eq!(value["server"], json!("figma"));
}
+#[test]
+fn list_resource_args_normalizes_server_and_cursor() {
+ let args: ListResourceArgs = serde_json::from_value(json!({
+ "server": " hosted ",
+ "cursor": " next-page "
+ }))
+ .expect("parse resource-list arguments");
+
+ assert_eq!(
+ args.normalized(),
+ ListResourceArgs {
+ server: Some("hosted".to_string()),
+ cursor: Some("next-page".to_string()),
+ }
+ );
+}
+
#[test]
fn template_with_server_serializes_server_field() {
- let entry = ResourceTemplateWithServer::new("srv".to_string(), template("memo://{id}", "memo"));
+ let entry = ResourceWithServer::new("srv".to_string(), template("memo://{id}", "memo"));
let value = serde_json::to_value(&entry).expect("serialize template");
assert_eq!(
@@ -103,6 +120,31 @@ fn template_with_server_serializes_server_field() {
);
}
+#[test]
+fn list_resource_templates_payload_from_all_servers_is_sorted() {
+ let mut templates_by_server = HashMap::new();
+ templates_by_server.insert(
+ "beta".to_string(),
+ vec![template("memo://beta/{id}", "beta")],
+ );
+ templates_by_server.insert(
+ "alpha".to_string(),
+ vec![template("memo://alpha/{id}", "alpha")],
+ );
+
+ let payload = ListResourceTemplatesPayload::from_all_servers(templates_by_server);
+
+ assert_eq!(
+ serde_json::to_value(payload).expect("serialize resource templates"),
+ json!({
+ "resourceTemplates": [
+ {"server": "alpha", "uriTemplate": "memo://alpha/{id}", "name": "alpha"},
+ {"server": "beta", "uriTemplate": "memo://beta/{id}", "name": "beta"}
+ ]
+ })
+ );
+}
+
#[test]
fn serialize_function_output_preserves_small_payload() {
let payload = json!({"server": "hosted", "resources": []});