remove mcp-server/src/mcp_protocol.rs and the code that depends on it (#2360)

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

@@ -1,5 +1,4 @@
 use std::collections::HashMap;
-use std::collections::HashSet;
 use std::path::PathBuf;
 use std::sync::Arc;
 
@@ -9,18 +8,12 @@ use crate::codex_tool_config::CodexToolCallReplyParam;
 use crate::codex_tool_config::create_tool_for_codex_tool_call_param;
 use crate::codex_tool_config::create_tool_for_codex_tool_call_reply_param;
 use crate::error_code::INVALID_REQUEST_ERROR_CODE;
-use crate::mcp_protocol::ToolCallRequestParams;
-use crate::mcp_protocol::ToolCallResponse;
-use crate::mcp_protocol::ToolCallResponseResult;
 use crate::outgoing_message::OutgoingMessageSender;
-use crate::tool_handlers::create_conversation::handle_create_conversation;
-use crate::tool_handlers::send_message::handle_send_message;
 use crate::wire_format::ClientRequest;
 
 use codex_core::ConversationManager;
 use codex_core::config::Config as CodexConfig;
 use codex_core::protocol::Submission;
-use mcp_types::CallToolRequest;
 use mcp_types::CallToolRequestParams;
 use mcp_types::CallToolResult;
 use mcp_types::ClientRequest as McpClientRequest;
@@ -48,7 +41,6 @@ pub(crate) struct MessageProcessor {
     codex_linux_sandbox_exe: Option<PathBuf>,
     conversation_manager: Arc<ConversationManager>,
     running_requests_id_to_codex_uuid: Arc<Mutex<HashMap<RequestId, Uuid>>>,
-    running_session_ids: Arc<Mutex<HashSet<Uuid>>>,
 }
 
 impl MessageProcessor {
@@ -72,22 +64,9 @@ impl MessageProcessor {
             codex_linux_sandbox_exe,
             conversation_manager,
             running_requests_id_to_codex_uuid: Arc::new(Mutex::new(HashMap::new())),
-            running_session_ids: Arc::new(Mutex::new(HashSet::new())),
         }
     }
 
-    pub(crate) fn get_conversation_manager(&self) -> &ConversationManager {
-        &self.conversation_manager
-    }
-
-    pub(crate) fn outgoing(&self) -> Arc<OutgoingMessageSender> {
-        self.outgoing.clone()
-    }
-
-    pub(crate) fn running_session_ids(&self) -> Arc<Mutex<HashSet<Uuid>>> {
-        self.running_session_ids.clone()
-    }
-
     pub(crate) async fn process_request(&mut self, request: JSONRPCRequest) {
         if let Ok(request_json) = serde_json::to_value(request.clone())
             && let Ok(codex_request) = serde_json::from_value::<ClientRequest>(request_json)
@@ -341,14 +320,6 @@ impl MessageProcessor {
         params: <mcp_types::CallToolRequest as mcp_types::ModelContextProtocolRequest>::Params,
     ) {
         tracing::info!("tools/call -> params: {:?}", params);
-        // Serialize params into JSON and try to parse as new type
-        if let Ok(new_params) =
-            serde_json::to_value(&params).and_then(serde_json::from_value::<ToolCallRequestParams>)
-        {
-            // New tool call matched → forward
-            self.handle_new_tool_calls(id, new_params).await;
-            return;
-        }
         let CallToolRequestParams { name, arguments } = params;
 
         match name.as_str() {
@@ -372,30 +343,6 @@ impl MessageProcessor {
             }
         }
     }
-    async fn handle_new_tool_calls(&self, request_id: RequestId, params: ToolCallRequestParams) {
-        match params {
-            ToolCallRequestParams::ConversationCreate(args) => {
-                handle_create_conversation(self, request_id, args).await;
-            }
-            ToolCallRequestParams::ConversationSendMessage(args) => {
-                handle_send_message(self, request_id, args).await;
-            }
-            _ => {
-                let result = CallToolResult {
-                    content: vec![ContentBlock::TextContent(TextContent {
-                        r#type: "text".to_string(),
-                        text: "Unknown tool".to_string(),
-                        annotations: None,
-                    })],
-                    is_error: Some(true),
-                    structured_content: None,
-                };
-                self.send_response::<CallToolRequest>(request_id, result)
-                    .await;
-            }
-        }
-    }
-
     async fn handle_tool_call_codex(&self, id: RequestId, arguments: Option<serde_json::Value>) {
         let (initial_prompt, config): (String, CodexConfig) = match arguments {
             Some(json_val) => match serde_json::from_value::<CodexToolCallParam>(json_val) {
@@ -692,20 +639,4 @@ impl MessageProcessor {
     ) {
         tracing::info!("notifications/message -> params: {:?}", params);
     }
-
-    pub(crate) async fn send_response_with_optional_error(
-        &self,
-        id: RequestId,
-        message: Option<ToolCallResponseResult>,
-        error: Option<bool>,
-    ) {
-        let response = ToolCallResponse {
-            request_id: id.clone(),
-            is_error: error,
-            result: message,
-        };
-        let result: CallToolResult = response.into();
-        self.send_response::<mcp_types::CallToolRequest>(id.clone(), result)
-            .await;
-    }
 }