Encode dates in ISO 8601, decode a string for a Date argument as ISO 8601 or unix time stamp

Author: odrobnik

Demos/SwiftMCPDemo/Calculator.swift

@@ -38,6 +38,30 @@ actor Calculator {
 		}
 	}
 
+	/**
+	  Gets the current date/time on the server
+	 - Returns: The current time
+	 */
+	@MCPTool
+	func getCurrentDateTime() -> Date {
+		return Date()
+	}
+	
+	/**
+	  Formats a date/time as String
+	  - Parameter date: The Date to format
+	  - Returns: A string with the date formatted
+	 */
+	@MCPTool
+	func formatDateAsString(date: Date) -> String {
+		
+		let dateFormatter = DateFormatter()
+		dateFormatter.dateStyle = .long
+		dateFormatter.timeStyle = .long
+		
+		return dateFormatter.string(from: date)
+	}
+	
     /// Adds two integers and returns their sum
     /// - Parameter a: First number to add
     /// - Parameter b: Second number to add

Sources/SwiftMCP/Extensions/Dictionary+ParameterExtraction.swift

@@ -45,6 +45,11 @@ public extension Dictionary where Key == String, Value == Sendable {
 			// return the actual enum case value that matches the string label
 			return allCases[index]
 		}
+        else if T.self == Date.self {
+            // Handle Date type using the new extractDate method
+            let date = try extractDate(named: name)
+            return date as! T
+        }
 		else {
             throw MCPToolError.invalidArgumentType(
                 parameterName: name,
@@ -165,4 +170,48 @@ public extension Dictionary where Key == String, Value == Sendable {
             )
         }
     }
+    
+    /// Extracts a Date parameter from the dictionary, attempting multiple parsing strategies
+    /// - Parameter name: The name of the parameter
+    /// - Returns: The extracted Date value
+    /// - Throws: MCPToolError.invalidArgumentType if the parameter cannot be converted to a Date
+    func extractDate(named name: String) throws -> Date {
+        guard let anyValue = self[name] else {
+            preconditionFailure("Failed to retrieve value for parameter \(name)")
+        }
+        
+        // If it's already a Date, return it
+        if let date = anyValue as? Date {
+            return date
+        }
+        
+        // Try parsing as string
+        if let stringValue = anyValue as? String {
+            // Try ISO 8601 date format
+            let isoFormatter = ISO8601DateFormatter()
+            if let date = isoFormatter.date(from: stringValue) {
+                return date
+            }
+            
+            // Try Unix timestamp (both integer and decimal)
+            if let timestampDouble = Double(stringValue) {
+                return Date(timeIntervalSince1970: timestampDouble)
+            }
+        }
+        
+        // Try direct conversion from number
+        if let timestampDouble = anyValue as? Double {
+            return Date(timeIntervalSince1970: timestampDouble)
+        }
+		
+        if let timestampInt = anyValue as? Int {
+            return Date(timeIntervalSince1970: TimeInterval(timestampInt))
+        }
+        
+        throw MCPToolError.invalidArgumentType(
+            parameterName: name,
+            expectedType: "ISO 8601 Date",
+            actualType: String(describing: Swift.type(of: anyValue))
+        )
+    }
 } 

Sources/SwiftMCP/Protocols/MCPServer.swift

@@ -252,7 +252,9 @@ public extension MCPServer {
 			}
 			else
 			{
-				let jsonData = try JSONEncoder().encode(result)
+				let encoder = JSONEncoder()
+				encoder.dateEncodingStrategy = .iso8601
+				let jsonData = try encoder.encode(result)
 				responseText = String(data: jsonData, encoding: .utf8) ?? ""
 			}
 

Sources/SwiftMCP/Transport/HTTPHandler.swift

@@ -245,8 +245,9 @@ final class HTTPHandler: ChannelInboundHandler, Identifiable, @unchecked Sendabl
 			return
 		}
 
-		let decoder = JSONDecoder()
 		do {
+			let decoder = JSONDecoder()
+			decoder.dateDecodingStrategy = .iso8601
 			let request = try decoder.decode(JSONRPCMessage.self, from: body)
 
 			if request.method == nil {

Sources/SwiftMCP/Transport/StdioTransport.swift

@@ -65,7 +65,9 @@ public final class StdioTransport: Transport, @unchecked Sendable {
 
 						logger.trace("Received input: \(input)")
 
-						let request = try JSONDecoder().decode(JSONRPCMessage.self, from: data)
+						let decoder = JSONDecoder()
+						decoder.dateDecodingStrategy = .iso8601
+						let request = try decoder.decode(JSONRPCMessage.self, from: data)
 
 						// Handle the request.
 						if let response = await server.handleRequest(request) {
@@ -107,7 +109,9 @@ public final class StdioTransport: Transport, @unchecked Sendable {
 
 				logger.trace("Received input: \(input)")
 
-				let request = try JSONDecoder().decode(JSONRPCMessage.self, from: data)
+				let decoder = JSONDecoder()
+				decoder.dateDecodingStrategy = .iso8601
+				let request = try decoder.decode(JSONRPCMessage.self, from: data)
 
 				// Handle the request.
 				if let response = await server.handleRequest(request) {

Tests/SwiftMCPTests/Calculator.swift

@@ -84,4 +84,13 @@ class Calculator {
 	func noop() {
 
 	}
+	
+	/**
+	  Gets the current date/time on the server
+	 - Returns: The current time
+	 */
+	@MCPTool
+	func getCurrentDateTime() -> Date {
+		return Date()
+	}
 }

Tests/SwiftMCPTests/CalculatorMockTests.swift

@@ -291,7 +291,43 @@ func testNoopViaMockClient() async throws {
 
     #expect(type == "text")
     #expect(text == "")  // noop returns empty string
-} 
+}
+
+@Test("Tests getCurrentDateTime returns ISO formatted date")
+func testGetCurrentDateTimeViaMockClient() async throws {
+    let calculator = Calculator()
+    let client = MockClient(calculator: calculator)
+    
+    let request = JSONRPCMessage(
+        id: 9,
+        method: "tools/call",
+        params: [
+            "name": "getCurrentDateTime",
+            "arguments": [:]
+        ]
+    )
+    
+    let response = try await client.send(request)
+    
+    #expect(response.id == 9)
+    #expect(response.error == nil)
+    
+    let result = unwrap(response.result)
+    let isError = unwrap(result["isError"]?.value as? Bool)
+    #expect(isError == false)
+    
+    let content = unwrap(result["content"]?.value as? [[String: String]])
+    let firstContent = unwrap(content.first)
+    let type = unwrap(firstContent["type"])
+    let text = unwrap(firstContent["text"])
+    
+    #expect(type == "text")
+    
+    // Verify the text is a valid ISO 8601 date string
+    let dateFormatter = ISO8601DateFormatter()
+    let date = dateFormatter.date(from: text.replacingOccurrences(of: "\"", with: ""))
+    #expect(date != nil, "Response should be a valid ISO 8601 date string")
+}
 
 /// Errors that can occur during MCP client operations
 public enum MCPError: LocalizedError {