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/rmcp-client/tests/resources.rs

@@ -7,15 +7,15 @@ use codex_rmcp_client::ElicitationResponse;
 use codex_rmcp_client::RmcpClient;
 use codex_utils_cargo_bin::CargoBinError;
 use futures::FutureExt as _;
-use mcp_types::ClientCapabilities;
-use mcp_types::Implementation;
-use mcp_types::InitializeRequestParams;
-use mcp_types::ListResourceTemplatesResult;
-use mcp_types::ReadResourceRequestParams;
-use mcp_types::ReadResourceResultContents;
-use mcp_types::Resource;
-use mcp_types::ResourceTemplate;
-use mcp_types::TextResourceContents;
+use rmcp::model::AnnotateAble;
+use rmcp::model::ClientCapabilities;
+use rmcp::model::ElicitationCapability;
+use rmcp::model::Implementation;
+use rmcp::model::InitializeRequestParam;
+use rmcp::model::ListResourceTemplatesResult;
+use rmcp::model::ProtocolVersion;
+use rmcp::model::ReadResourceRequestParam;
+use rmcp::model::ResourceContents;
 use serde_json::json;
 
 const RESOURCE_URI: &str = "memo://codex/example-note";
@@ -24,21 +24,24 @@ fn stdio_server_bin() -> Result<PathBuf, CargoBinError> {
     codex_utils_cargo_bin::cargo_bin("test_stdio_server")
 }
 
-fn init_params() -> InitializeRequestParams {
-    InitializeRequestParams {
+fn init_params() -> InitializeRequestParam {
+    InitializeRequestParam {
         capabilities: ClientCapabilities {
             experimental: None,
             roots: None,
             sampling: None,
-            elicitation: Some(json!({})),
+            elicitation: Some(ElicitationCapability {
+                schema_validation: None,
+            }),
         },
         client_info: Implementation {
             name: "codex-test".into(),
             version: "0.0.0-test".into(),
             title: Some("Codex rmcp resource test".into()),
-            user_agent: None,
+            icons: None,
+            website_url: None,
         },
-        protocol_version: mcp_types::MCP_SCHEMA_VERSION.to_string(),
+        protocol_version: ProtocolVersion::V_2025_06_18,
     }
 }
 
@@ -79,15 +82,17 @@ async fn rmcp_client_can_list_and_read_resources() -> anyhow::Result<()> {
         .expect("memo resource present");
     assert_eq!(
         memo,
-        &Resource {
-            annotations: None,
+        &rmcp::model::RawResource {
+            uri: RESOURCE_URI.to_string(),
+            name: "example-note".to_string(),
+            title: Some("Example Note".to_string()),
             description: Some("A sample MCP resource exposed for integration tests.".to_string()),
             mime_type: Some("text/plain".to_string()),
-            name: "example-note".to_string(),
             size: None,
-            title: Some("Example Note".to_string()),
-            uri: RESOURCE_URI.to_string(),
+            icons: None,
+            meta: None,
         }
+        .no_annotation()
     );
     let templates = client
         .list_resource_templates(None, Some(Duration::from_secs(5)))
@@ -95,39 +100,39 @@ async fn rmcp_client_can_list_and_read_resources() -> anyhow::Result<()> {
     assert_eq!(
         templates,
         ListResourceTemplatesResult {
+            meta: None,
             next_cursor: None,
-            resource_templates: vec![ResourceTemplate {
-                annotations: None,
-                description: Some(
-                    "Template for memo://codex/{slug} resources used in tests.".to_string()
-                ),
-                mime_type: Some("text/plain".to_string()),
-                name: "codex-memo".to_string(),
-                title: Some("Codex Memo".to_string()),
-                uri_template: "memo://codex/{slug}".to_string(),
-            }],
+            resource_templates: vec![
+                rmcp::model::RawResourceTemplate {
+                    uri_template: "memo://codex/{slug}".to_string(),
+                    name: "codex-memo".to_string(),
+                    title: Some("Codex Memo".to_string()),
+                    description: Some(
+                        "Template for memo://codex/{slug} resources used in tests.".to_string(),
+                    ),
+                    mime_type: Some("text/plain".to_string()),
+                }
+                .no_annotation()
+            ],
         }
     );
 
     let read = client
         .read_resource(
-            ReadResourceRequestParams {
+            ReadResourceRequestParam {
                 uri: RESOURCE_URI.to_string(),
             },
             Some(Duration::from_secs(5)),
         )
         .await?;
-    let ReadResourceResultContents::TextResourceContents(text) =
-        read.contents.first().expect("resource contents present")
-    else {
-        panic!("expected text resource");
-    };
+    let text = read.contents.first().expect("resource contents present");
     assert_eq!(
         text,
-        &TextResourceContents {
-            text: "This is a sample MCP resource served by the rmcp test server.".to_string(),
+        &ResourceContents::TextResourceContents {
             uri: RESOURCE_URI.to_string(),
             mime_type: Some("text/plain".to_string()),
+            text: "This is a sample MCP resource served by the rmcp test server.".to_string(),
+            meta: None,
         }
     );