Upgrade rmcp to 3.0.0-beta.3

codex-rs/Cargo.toml

@@ -377,7 +377,7 @@ rcgen = { version = "0.14.7", default-features = false, features = [
 regex = "1.12.3"
 regex-lite = "0.1.8"
 reqwest = { version = "0.12", features = ["cookies"] }
-rmcp = { version = "1.8.0", default-features = false }
+rmcp = { version = "=3.0.0-beta.3", default-features = false }
 runfiles = { git = "https://github.com/dzbarsky/rules_rust", rev = "b56cbaa8465e74127f1ea216f813cd377295ad81" }
 rustls = { version = "0.23", default-features = false, features = [
     "aws_lc_rs",

codex-rs/app-server-protocol/src/protocol/v2/mcp.rs

@@ -287,6 +287,7 @@ impl From<rmcp::model::ElicitationAction> for McpServerElicitationAction {
             rmcp::model::ElicitationAction::Accept => Self::Accept,
             rmcp::model::ElicitationAction::Decline => Self::Decline,
             rmcp::model::ElicitationAction::Cancel => Self::Cancel,
+            _ => Self::Cancel,
         }
     }
 }
@@ -344,10 +345,38 @@ pub enum McpElicitationObjectType {
 pub enum McpElicitationPrimitiveSchema {
     Enum(McpElicitationEnumSchema),
     String(McpElicitationStringSchema),
+    #[serde(serialize_with = "serialize_mcp_elicitation_number_schema")]
     Number(McpElicitationNumberSchema),
     Boolean(McpElicitationBooleanSchema),
 }
 
+fn serialize_mcp_elicitation_number_schema<S>(
+    schema: &McpElicitationNumberSchema,
+    serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    if schema.type_ != McpElicitationNumberType::Integer {
+        return schema.serialize(serializer);
+    }
+
+    let mut value = serde_json::to_value(schema).map_err(serde::ser::Error::custom)?;
+    if let Some(object) = value.as_object_mut() {
+        for key in ["minimum", "maximum", "default"] {
+            if let Some(value) = object.get_mut(key)
+                && let Some(number) = value.as_f64()
+                && number.fract() == 0.0
+                && number >= i64::MIN as f64
+                && number < -(i64::MIN as f64)
+            {
+                *value = serde_json::Value::from(number as i64);
+            }
+        }
+    }
+    value.serialize(serializer)
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
 #[ts(export_to = "v2/")]
@@ -716,18 +745,16 @@ pub struct McpServerElicitationRequestResponse {
     pub meta: Option<JsonValue>,
 }
 
-impl From<McpServerElicitationRequestResponse> for rmcp::model::CreateElicitationResult {
+impl From<McpServerElicitationRequestResponse> for rmcp::model::ElicitResult {
     fn from(value: McpServerElicitationRequestResponse) -> Self {
-        Self {
-            action: value.action.into(),
-            content: value.content,
-            meta: None,
-        }
+        let mut result = Self::new(value.action.into());
+        result.content = value.content;
+        result
     }
 }
 
-impl From<rmcp::model::CreateElicitationResult> for McpServerElicitationRequestResponse {
-    fn from(value: rmcp::model::CreateElicitationResult) -> Self {
+impl From<rmcp::model::ElicitResult> for McpServerElicitationRequestResponse {
+    fn from(value: rmcp::model::ElicitResult) -> Self {
         Self {
             action: value.action.into(),
             content: value.content,

codex-rs/app-server-protocol/src/protocol/v2/tests.rs

@@ -1989,13 +1989,10 @@ fn client_request_turn_start_granular_approval_policy_is_marked_experimental() {
 
 #[test]
 fn mcp_server_elicitation_response_round_trips_rmcp_result() {
-    let rmcp_result = rmcp::model::CreateElicitationResult {
-        action: rmcp::model::ElicitationAction::Accept,
-        content: Some(json!({
+    let rmcp_result = rmcp::model::ElicitResult::new(rmcp::model::ElicitationAction::Accept)
+        .with_content(json!({
             "confirmed": true,
-        })),
-        meta: None,
-    };
+        }));
 
     let v2_response = McpServerElicitationRequestResponse::from(rmcp_result.clone());
     assert_eq!(
@@ -2008,10 +2005,7 @@ fn mcp_server_elicitation_response_round_trips_rmcp_result() {
             meta: None,
         }
     );
-    assert_eq!(
-        rmcp::model::CreateElicitationResult::from(v2_response),
-        rmcp_result
-    );
+    assert_eq!(rmcp::model::ElicitResult::from(v2_response), rmcp_result);
 }
 
 #[test]
@@ -2204,6 +2198,45 @@ fn mcp_elicitation_schema_matches_mcp_2025_11_25_primitives() {
     );
 }
 
+#[test]
+fn mcp_elicitation_preserves_integer_and_number_schema_wire_values() {
+    for (number_type, expected_type, expected_minimum, expected_maximum, expected_default) in [
+        (
+            McpElicitationNumberType::Integer,
+            "integer",
+            json!(1),
+            json!(99),
+            json!(30),
+        ),
+        (
+            McpElicitationNumberType::Number,
+            "number",
+            json!(1.0),
+            json!(99.0),
+            json!(30.0),
+        ),
+    ] {
+        let schema = McpElicitationPrimitiveSchema::Number(McpElicitationNumberSchema {
+            type_: number_type,
+            title: None,
+            description: None,
+            minimum: Some(1.0),
+            maximum: Some(99.0),
+            default: Some(30.0),
+        });
+
+        assert_eq!(
+            serde_json::to_value(schema).expect("numeric elicitation schema must serialize"),
+            json!({
+                "type": expected_type,
+                "minimum": expected_minimum,
+                "maximum": expected_maximum,
+                "default": expected_default,
+            })
+        );
+    }
+}
+
 #[test]
 fn mcp_server_elicitation_request_rejects_null_core_form_schema() {
     let result = McpServerElicitationRequest::try_from(CoreElicitationRequest::Form {

codex-rs/app-server/tests/suite/v2/app_installed.rs

@@ -330,15 +330,13 @@ impl ServerHandler for InstalledAppsMcpServer {
                 ));
             }
 
-            Ok(ListToolsResult {
-                meta: None,
-                next_cursor: None,
-                tools: state
+            Ok(ListToolsResult::with_all_items(
+                state
                     .tools
                     .lock()
                     .unwrap_or_else(std::sync::PoisonError::into_inner)
                     .clone(),
-            })
+            ))
         }
     }
 }

codex-rs/app-server/tests/suite/v2/app_list.rs

@@ -1581,11 +1581,7 @@ impl ServerHandler for AppListMcpServer {
                 .lock()
                 .unwrap_or_else(std::sync::PoisonError::into_inner)
                 .clone();
-            Ok(ListToolsResult {
-                tools,
-                next_cursor: None,
-                meta: None,
-            })
+            Ok(ListToolsResult::with_all_items(tools))
         }
     }
 }

codex-rs/app-server/tests/suite/v2/executor_mcp.rs

@@ -419,18 +419,14 @@ impl ServerHandler for ExecutorHttpMcpServer {
         );
         tool.annotations = Some(ToolAnnotations::new().read_only(true));
 
-        Ok(ListToolsResult {
-            tools: vec![tool],
-            next_cursor: None,
-            meta: None,
-        })
+        Ok(ListToolsResult::with_all_items(vec![tool]))
     }
 
     async fn call_tool(
         &self,
         request: CallToolRequestParams,
         _context: RequestContext<RoleServer>,
-    ) -> Result<CallToolResult, rmcp::ErrorData> {
+    ) -> Result<rmcp::model::CallToolResponse, rmcp::ErrorData> {
         let message = request
             .arguments
             .as_ref()
@@ -439,7 +435,8 @@ impl ServerHandler for ExecutorHttpMcpServer {
             .unwrap_or_default();
         Ok(CallToolResult::structured(json!({
             "echo": format!("ECHOING: {message}")
-        })))
+        }))
+        .into())
     }
 }