draft: use rust messages in typescript (#1393)

2025-02-27 04:02:43 +01:00
parent 552facb7ef
commit 0602b35ddc
19 changed files with 1224 additions and 1537 deletions
@@ -14,19 +14,26 @@ use mcp_core::role::Role;
 use mcp_core::tool::ToolCall;
 use serde_json::Value;

+mod tool_result_serde;
+
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub struct ToolRequest {
    pub id: String,
+    #[serde(with = "tool_result_serde")]
    pub tool_call: ToolResult<ToolCall>,
 }

 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub struct ToolResponse {
    pub id: String,
+    #[serde(with = "tool_result_serde")]
    pub tool_result: ToolResult<Vec<Content>>,
 }

 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub struct ToolConfirmationRequest {
    pub id: String,
    pub tool_name: String,
@@ -36,6 +43,7 @@ pub struct ToolConfirmationRequest {

 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
 /// Content passed inside a message, which can be both simple content and tool content
+#[serde(tag = "type", rename_all = "camelCase")]
 pub enum MessageContent {
    Text(TextContent),
    Image(ImageContent),
@@ -150,6 +158,7 @@ impl From<Content> for MessageContent {

 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
 /// A message to or from an LLM
+#[serde(rename_all = "camelCase")]
 pub struct Message {
    pub role: Role,
    pub created: i64,
@@ -292,3 +301,123 @@ impl Message {
            .all(|c| matches!(c, MessageContent::Text(_)))
    }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use mcp_core::handler::ToolError;
+    use serde_json::{json, Value};
+
+    #[test]
+    fn test_message_serialization() {
+        let message = Message::assistant()
+            .with_text("Hello, I'll help you with that.")
+            .with_tool_request(
+                "tool123",
+                Ok(ToolCall::new("test_tool", json!({"param": "value"}))),
+            );
+
+        let json_str = serde_json::to_string_pretty(&message).unwrap();
+        println!("Serialized message: {}", json_str);
+
+        // Parse back to Value to check structure
+        let value: Value = serde_json::from_str(&json_str).unwrap();
+
+        // Check top-level fields
+        assert_eq!(value["role"], "assistant");
+        assert!(value["created"].is_i64());
+        assert!(value["content"].is_array());
+
+        // Check content items
+        let content = &value["content"];
+
+        // First item should be text
+        assert_eq!(content[0]["type"], "text");
+        assert_eq!(content[0]["text"], "Hello, I'll help you with that.");
+
+        // Second item should be toolRequest
+        assert_eq!(content[1]["type"], "toolRequest");
+        assert_eq!(content[1]["id"], "tool123");
+
+        // Check tool_call serialization
+        assert_eq!(content[1]["toolCall"]["status"], "success");
+        assert_eq!(content[1]["toolCall"]["value"]["name"], "test_tool");
+        assert_eq!(
+            content[1]["toolCall"]["value"]["arguments"]["param"],
+            "value"
+        );
+    }
+
+    #[test]
+    fn test_error_serialization() {
+        let message = Message::assistant().with_tool_request(
+            "tool123",
+            Err(ToolError::ExecutionError(
+                "Something went wrong".to_string(),
+            )),
+        );
+
+        let json_str = serde_json::to_string_pretty(&message).unwrap();
+        println!("Serialized error: {}", json_str);
+
+        // Parse back to Value to check structure
+        let value: Value = serde_json::from_str(&json_str).unwrap();
+
+        // Check tool_call serialization with error
+        let tool_call = &value["content"][0]["toolCall"];
+        assert_eq!(tool_call["status"], "error");
+        assert_eq!(tool_call["error"], "Execution failed: Something went wrong");
+    }
+
+    #[test]
+    fn test_deserialization() {
+        // Create a JSON string with our new format
+        let json_str = r#"{
+            "role": "assistant",
+            "created": 1740171566,
+            "content": [
+                {
+                    "type": "text",
+                    "text": "I'll help you with that."
+                },
+                {
+                    "type": "toolRequest",
+                    "id": "tool123",
+                    "toolCall": {
+                        "status": "success",
+                        "value": {
+                            "name": "test_tool",
+                            "arguments": {"param": "value"}
+                        }
+                    }
+                }
+            ]
+        }"#;
+
+        let message: Message = serde_json::from_str(json_str).unwrap();
+
+        assert_eq!(message.role, Role::Assistant);
+        assert_eq!(message.created, 1740171566);
+        assert_eq!(message.content.len(), 2);
+
+        // Check first content item
+        if let MessageContent::Text(text) = &message.content[0] {
+            assert_eq!(text.text, "I'll help you with that.");
+        } else {
+            panic!("Expected Text content");
+        }
+
+        // Check second content item
+        if let MessageContent::ToolRequest(req) = &message.content[1] {
+            assert_eq!(req.id, "tool123");
+            if let Ok(tool_call) = &req.tool_call {
+                assert_eq!(tool_call.name, "test_tool");
+                assert_eq!(tool_call.arguments, json!({"param": "value"}));
+            } else {
+                panic!("Expected successful tool call");
+            }
+        } else {
+            panic!("Expected ToolRequest content");
+        }
+    }
+}
@@ -0,0 +1,64 @@
+use mcp_core::handler::{ToolError, ToolResult};
+use serde::ser::SerializeStruct;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+pub fn serialize<T, S>(value: &ToolResult<T>, serializer: S) -> Result<S::Ok, S::Error>
+where
+    T: Serialize,
+    S: Serializer,
+{
+    match value {
+        Ok(val) => {
+            let mut state = serializer.serialize_struct("ToolResult", 2)?;
+            state.serialize_field("status", "success")?;
+            state.serialize_field("value", val)?;
+            state.end()
+        }
+        Err(err) => {
+            let mut state = serializer.serialize_struct("ToolResult", 2)?;
+            state.serialize_field("status", "error")?;
+            state.serialize_field("error", &err.to_string())?;
+            state.end()
+        }
+    }
+}
+
+// For deserialization, let's use a simpler approach that works with the format we're serializing to
+pub fn deserialize<'de, T, D>(deserializer: D) -> Result<ToolResult<T>, D::Error>
+where
+    T: Deserialize<'de>,
+    D: Deserializer<'de>,
+{
+    // Define a helper enum to handle the two possible formats
+    #[derive(Deserialize)]
+    #[serde(untagged)]
+    enum ResultFormat<T> {
+        Success { status: String, value: T },
+        Error { status: String, error: String },
+    }
+
+    let format = ResultFormat::deserialize(deserializer)?;
+
+    match format {
+        ResultFormat::Success { status, value } => {
+            if status == "success" {
+                Ok(Ok(value))
+            } else {
+                Err(serde::de::Error::custom(format!(
+                    "Expected status 'success', got '{}'",
+                    status
+                )))
+            }
+        }
+        ResultFormat::Error { status, error } => {
+            if status == "error" {
+                Ok(Err(ToolError::ExecutionError(error)))
+            } else {
+                Err(serde::de::Error::custom(format!(
+                    "Expected status 'error', got '{}'",
+                    status
+                )))
+            }
+        }
+    }
+}