feat: replace custom mcp-types crate with equivalents from rmcp (#10349)

We started working with MCP in Codex before
https://crates.io/crates/rmcp was mature, so we had our own crate for
MCP types that was generated from the MCP schema:


8b95d3e082/codex-rs/mcp-types/README.md

Now that `rmcp` is more mature, it makes more sense to use their MCP
types in Rust, as they handle details (like the `_meta` field) that our
custom version ignored. Though one advantage that our custom types had
is that our generated types implemented `JsonSchema` and `ts_rs::TS`,
whereas the types in `rmcp` do not. As such, part of the work of this PR
is leveraging the adapters between `rmcp` types and the serializable
types that are API for us (app server and MCP) introduced in #10356.

Note this PR results in a number of changes to
`codex-rs/app-server-protocol/schema`, which merit special attention
during review. We must ensure that these changes are still
backwards-compatible, which is possible because we have:

```diff
- export type CallToolResult = { content: Array<ContentBlock>, isError?: boolean, structuredContent?: JsonValue, };
+ export type CallToolResult = { content: Array<JsonValue>, structuredContent?: JsonValue, isError?: boolean, _meta?: JsonValue, };
```

so `ContentBlock` has been replaced with the more general `JsonValue`.
Note that `ContentBlock` was defined as:

```typescript
export type ContentBlock = TextContent | ImageContent | AudioContent | ResourceLink | EmbeddedResource;
```

so the deletion of those individual variants should not be a cause of
great concern.

Similarly, we have the following change in
`codex-rs/app-server-protocol/schema/typescript/Tool.ts`:

```
- export type Tool = { annotations?: ToolAnnotations, description?: string, inputSchema: ToolInputSchema, name: string, outputSchema?: ToolOutputSchema, title?: string, };
+ export type Tool = { name: string, title?: string, description?: string, inputSchema: JsonValue, outputSchema?: JsonValue, annotations?: JsonValue, icons?: Array<JsonValue>, _meta?: JsonValue, };
```

so:

- `annotations?: ToolAnnotations` ➡️ `JsonValue`
- `inputSchema: ToolInputSchema` ➡️ `JsonValue`
- `outputSchema?: ToolOutputSchema` ➡️ `JsonValue`

and two new fields: `icons?: Array<JsonValue>, _meta?: JsonValue`

---
[//]: # (BEGIN SAPLING FOOTER)
Stack created with [Sapling](https://sapling-scm.com). Best reviewed
with [ReviewStack](https://reviewstack.dev/openai/codex/pull/10349).
* #10357
* __->__ #10349
* #10356

codex-rs/mcp-server/src/codex_tool_config.rs

@@ -6,15 +6,15 @@ use codex_core::protocol::AskForApproval;
 use codex_protocol::ThreadId;
 use codex_protocol::config_types::SandboxMode;
 use codex_utils_json_to_toml::json_to_toml;
-use mcp_types::Tool;
-use mcp_types::ToolInputSchema;
-use mcp_types::ToolOutputSchema;
+use rmcp::model::JsonObject;
+use rmcp::model::Tool;
 use schemars::JsonSchema;
 use schemars::r#gen::SchemaSettings;
 use serde::Deserialize;
 use serde::Serialize;
 use std::collections::HashMap;
 use std::path::PathBuf;
+use std::sync::Arc;
 
 /// Client-supplied configuration for a `codex` tool-call.
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, Default)]
@@ -115,35 +115,35 @@ pub(crate) fn create_tool_for_codex_tool_call_param() -> Tool {
         .into_generator()
         .into_root_schema_for::<CodexToolCallParam>();
 
-    #[expect(clippy::expect_used)]
-    let schema_value =
-        serde_json::to_value(&schema).expect("Codex tool schema should serialise to JSON");
-
-    let tool_input_schema =
-        serde_json::from_value::<ToolInputSchema>(schema_value).unwrap_or_else(|e| {
-            panic!("failed to create Tool from schema: {e}");
-        });
+    let input_schema = create_tool_input_schema(schema, "Codex tool schema should serialize");
 
     Tool {
-        name: "codex".to_string(),
+        name: "codex".into(),
         title: Some("Codex".to_string()),
-        input_schema: tool_input_schema,
+        input_schema,
         output_schema: Some(codex_tool_output_schema()),
         description: Some(
-            "Run a Codex session. Accepts configuration parameters matching the Codex Config struct.".to_string(),
+            "Run a Codex session. Accepts configuration parameters matching the Codex Config struct."
+                .into(),
         ),
         annotations: None,
+        icons: None,
+        meta: None,
     }
 }
 
-fn codex_tool_output_schema() -> ToolOutputSchema {
-    ToolOutputSchema {
-        properties: Some(serde_json::json!({
+fn codex_tool_output_schema() -> Arc<JsonObject> {
+    let schema = serde_json::json!({
+        "type": "object",
+        "properties": {
             "threadId": { "type": "string" },
             "content": { "type": "string" }
-        })),
-        required: Some(vec!["threadId".to_string(), "content".to_string()]),
-        r#type: "object".to_string(),
+        },
+        "required": ["threadId", "content"],
+    });
+    match schema {
+        serde_json::Value::Object(map) => Arc::new(map),
+        _ => unreachable!("json literal must be an object"),
     }
 }
 
@@ -237,27 +237,46 @@ pub(crate) fn create_tool_for_codex_tool_call_reply_param() -> Tool {
         .into_generator()
         .into_root_schema_for::<CodexToolCallReplyParam>();
 
-    #[expect(clippy::expect_used)]
-    let schema_value =
-        serde_json::to_value(&schema).expect("Codex reply tool schema should serialise to JSON");
-
-    let tool_input_schema =
-        serde_json::from_value::<ToolInputSchema>(schema_value).unwrap_or_else(|e| {
-            panic!("failed to create Tool from schema: {e}");
-        });
+    let input_schema = create_tool_input_schema(schema, "Codex reply tool schema should serialize");
 
     Tool {
-        name: "codex-reply".to_string(),
+        name: "codex-reply".into(),
         title: Some("Codex Reply".to_string()),
-        input_schema: tool_input_schema,
+        input_schema,
         output_schema: Some(codex_tool_output_schema()),
         description: Some(
-            "Continue a Codex conversation by providing the thread id and prompt.".to_string(),
+            "Continue a Codex conversation by providing the thread id and prompt.".into(),
         ),
         annotations: None,
+        icons: None,
+        meta: None,
     }
 }
 
+fn create_tool_input_schema(
+    schema: schemars::schema::RootSchema,
+    panic_message: &str,
+) -> Arc<JsonObject> {
+    #[expect(clippy::expect_used)]
+    let schema_value = serde_json::to_value(&schema).expect(panic_message);
+    let mut schema_object = match schema_value {
+        serde_json::Value::Object(object) => object,
+        _ => panic!("tool schema should serialize to a JSON object"),
+    };
+
+    // Prefer keeping the "core" JSON Schema keys while still preserving `$defs`
+    // in case any `$ref` leaks into the generated schema (even though we try
+    // to inline subschemas).
+    let mut input_schema = JsonObject::new();
+    for key in ["properties", "required", "type", "$defs", "definitions"] {
+        if let Some(value) = schema_object.remove(key) {
+            input_schema.insert(key.to_string(), value);
+        }
+    }
+
+    Arc::new(input_schema)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;