Added experimental resources support, ping command

Author: odrobnik

Sources/SwiftMCP/Models/MCPResource.swift

@@ -0,0 +1,31 @@
+import Foundation
+
+/// Protocol defining the requirements for an MCP resource
+public protocol MCPResource: Codable {
+    /// The URI of the resource
+    var uri: URL { get }
+    
+    /// The name of the resource
+    var name: String { get }
+    
+    /// The description of the resource
+    var description: String { get }
+    
+    /// The MIME type of the resource
+    var mimeType: String { get }
+}
+
+
+/// Errors that can occur when working with MCPResources
+public enum MCPResourceError: Error, CustomStringConvertible {
+    /// The URI string is invalid
+    case invalidURI(String)
+    
+    /// A description of the error
+    public var description: String {
+        switch self {
+        case .invalidURI(let uriString):
+            return "Invalid URI: \(uriString)"
+        }
+    }
+} 

Sources/SwiftMCP/Models/MCPResourceContent.swift

@@ -0,0 +1,16 @@
+import Foundation
+
+/// Protocol defining the requirements for MCP resource content
+public protocol MCPResourceContent: Codable {
+    /// The URI of the resource
+    var uri: URL { get }
+    
+    /// The MIME type of the resource (optional)
+    var mimeType: String? { get }
+    
+    /// The text content of the resource (if it's a text resource)
+    var text: String? { get }
+    
+    /// The binary content of the resource (if it's a binary resource)
+    var blob: Data? { get }
+}

Sources/SwiftMCP/Models/MCPResourceTemplate.swift

@@ -0,0 +1,16 @@
+import Foundation
+
+/// Protocol defining the requirements for an MCP resource template
+public protocol MCPResourceTemplate: Codable {
+    /// The URI of the resource
+    var uriTemplate: URL { get }
+    
+    /// The name of the resource
+    var name: String { get }
+    
+    /// The description of the resource
+    var description: String { get }
+    
+    /// The MIME type of the resource
+    var mimeType: String { get }
+}

Sources/SwiftMCP/Protocols/MCPServer.swift

@@ -6,6 +6,13 @@ public protocol MCPServer {
     /// Returns an array of all MCP tools defined in this type
     var mcpTools: [MCPTool] { get }
 
+    /// Returns an array of all MCP resources defined in this type
+    var mcpResources: [MCPResource] { get }
+	
+	/// Returns an array of all MCP resource templates defined in this type
+	var mcpResourceTemplates: [MCPResourceTemplate] { get }
+
+    
     /// Calls a tool by name with the provided arguments
     /// - Parameters:
     ///   - name: The name of the tool to call
@@ -14,12 +21,25 @@ public protocol MCPServer {
     /// - Throws: MCPToolError if the tool doesn't exist or cannot be called
     func callTool(_ name: String, arguments: [String: Any]) throws -> Any
 
+    /// Gets a resource by URI
+    /// - Parameter uri: The URI of the resource to get
+    /// - Returns: The resource content, or nil if the resource doesn't exist
+    /// - Throws: MCPResourceError if there's an error getting the resource
+    func getResource(uri: URL) throws -> MCPResourceContent?
+    
     /// Handles a JSON-RPC request
     /// - Parameter request: The JSON-RPC request to handle
     /// - Returns: The response as a string, or nil if no response should be sent
     func handleRequest(_ request: JSONRPCRequest) -> Codable?
 }
 
+public enum MCPResourceKind
+{
+	case text(String)
+	
+	case data(Data)
+}
+
 // MARK: - Default Implementations
 public extension MCPServer {
     /// Handles a JSON-RPC request with default implementation
@@ -35,9 +55,21 @@ public extension MCPServer {
             case "notifications/initialized":
                 return nil
 
+            case "ping":
+                return createPingResponse(id: request.id ?? 0)
+                
             case "tools/list":
                 return createToolsResponse(id: request.id ?? 0)
 
+            case "resources/list":
+                return createResourcesListResponse(id: request.id ?? 0)
+                
+            case "resources/templates/list":
+                return createResourceTemplatesListResponse(id: request.id ?? 0)
+                
+            case "resources/read":
+                return createResourcesReadResponse(id: request.id ?? 0, request: request)
+                
             case "tools/call":
                 return handleToolCall(request)
 
@@ -54,6 +86,7 @@ public extension MCPServer {
             "protocolVersion": "2024-11-05",
             "capabilities": [
                 "experimental": [:],
+				"resources": ["listChanged": false],
                 "tools": ["listChanged": false]
             ],
             "serverInfo": [
@@ -65,6 +98,27 @@ public extension MCPServer {
         return JSONRPC.Response(id: .number(id), result: .init(responseDict))
     }
 
+    /// Creates a resources list response
+    /// - Parameter id: The request ID
+    /// - Returns: The resources list response
+    func createResourcesListResponse(id: Int) -> JSONRPC.Response {
+        // Convert MCPResource objects to dictionaries
+        let resourceDicts = mcpResources.map { resource -> [String: Any] in
+            return [
+                "uri": resource.uri.absoluteString,
+                "name": resource.name,
+                "description": resource.description,
+                "mimeType": resource.mimeType
+            ]
+        }
+        
+        let resourcesList: [String: Any] = [
+			"resources": resourceDicts
+        ]
+        
+        return JSONRPC.Response(id: .number(id), result: .init(resourcesList))
+    }
+    
     /// Creates a tools response
     /// - Parameter id: The request ID
     /// - Returns: The tools response
@@ -130,4 +184,115 @@ public extension MCPServer {
     private var serverVersion: String {
         Mirror(reflecting: self).children.first(where: { $0.label == "__mcpServerVersion" })?.value as? String ?? "UnknownVersion"
     }
-} 
+    
+    /// Creates a resources read response
+    /// - Parameters:
+    ///   - id: The request ID
+    ///   - request: The original JSON-RPC request
+    /// - Returns: The resources read response
+    func createResourcesReadResponse(id: Int, request: JSONRPCRequest) -> JSONRPC.Response {
+        // Extract the URI from the request params
+        guard let uriString = request.params?["uri"]?.value as? String,
+              let uri = URL(string: uriString) else {
+            // If no URI is provided or it's invalid, return an error
+            let errorDict: [String: Any] = [
+                "error": "Invalid or missing URI parameter"
+            ]
+            return JSONRPC.Response(id: .number(id), result: .init(errorDict))
+        }
+        
+        do {
+            // Try to get the resource content
+            if let resourceContent = try getResource(uri: uri) {
+                // Convert MCPResourceContent to dictionary
+                var contentDict: [String: Any] = [
+                    "uri": resourceContent.uri.absoluteString
+                ]
+                
+                // Add optional fields if they exist
+                if let mimeType = resourceContent.mimeType {
+                    contentDict["mimeType"] = mimeType
+                }
+                
+                if let text = resourceContent.text {
+                    contentDict["text"] = text
+                }
+                
+                if let blob = resourceContent.blob {
+                    // Convert binary data to base64 string
+                    contentDict["blob"] = blob.base64EncodedString()
+                }
+                
+                // Create the response
+                let responseDict: [String: Any] = [
+                    "contents": [contentDict]
+                ]
+                
+                return JSONRPC.Response(id: .number(id), result: .init(responseDict))
+            } else {
+                // Resource not found
+                let errorDict: [String: Any] = [
+                    "error": "Resource not found: \(uri.absoluteString)"
+                ]
+                return JSONRPC.Response(id: .number(id), result: .init(errorDict))
+            }
+        } catch {
+            // Error getting resource
+            let errorDict: [String: Any] = [
+                "error": "Error getting resource: \(error.localizedDescription)"
+            ]
+            return JSONRPC.Response(id: .number(id), result: .init(errorDict))
+        }
+    }
+    
+    /// Creates a resource templates list response
+    /// - Parameter id: The request ID
+    /// - Returns: The resource templates list response
+    func createResourceTemplatesListResponse(id: Int) -> JSONRPC.Response {
+        // Convert MCPResourceTemplate objects to dictionaries
+        let templateDicts = mcpResourceTemplates.map { template -> [String: Any] in
+            return [
+                "uriTemplate": template.uriTemplate.absoluteString,
+                "name": template.name,
+                "description": template.description,
+                "mimeType": template.mimeType
+            ]
+        }
+        
+        let templatesResponse: [String: Any] = [
+            "resourceTemplates": templateDicts
+        ]
+        
+        return JSONRPC.Response(id: .number(id), result: .init(templatesResponse))
+    }
+    
+    /// Creates a ping response
+    /// - Parameter id: The request ID
+    /// - Returns: The ping response
+    func createPingResponse(id: Int) -> JSONRPC.Response {
+        // Create an empty result object
+        let emptyResult: [String: Any] = [:]
+        
+        // Return a response with the empty result
+        return JSONRPC.Response(id: .number(id), result: .init(emptyResult))
+    }
+    
+    /// Default implementation for mcpResources
+    var mcpResources: [MCPResource] {
+        // By default, return an empty array
+        // Implementations can override this to provide actual resources
+        return []
+    }
+	
+	/// Default implementation for mcpResources
+	var mcpResourceTemplates: [MCPResourceTemplate] {
+		// By default, return an empty array
+		// Implementations can override this to provide actual resources
+		return []
+	}
+
+	/// Default implementation
+	func getResource(uri: URL) throws -> MCPResourceContent? {
+		return nil
+	}
+}

Sources/SwiftMCPDemo/Calculator.swift

@@ -1,8 +1,8 @@
 import Foundation
 import SwiftMCP
 
-@MCPServer(name: "Custom Calculator", version: "0.1")
-struct Calculator {
+@MCPServer(name: "Calculator", version: "1.0.0")
+class Calculator {
     /// Adds two integers and returns their sum
     /// - Parameter a: First number to add
     /// - Parameter b: Second number to add
@@ -64,4 +64,77 @@ struct Calculator {
 	func ping() -> String {
 		return "pong"
 	}
+    
+    /// Returns an array of all MCP resources defined in this type
+    var mcpResources: [MCPResource] {
+        // Get the Downloads folder URL
+        guard let downloadsURL = FileManager.default.urls(for: .downloadsDirectory, in: .userDomainMask).first else {
+            logToStderr("Could not get Downloads folder URL")
+            return []
+        }
+        
+        do {
+            // List all files in the Downloads folder
+            let fileURLs = try FileManager.default.contentsOfDirectory(
+                at: downloadsURL,
+                includingPropertiesForKeys: [.isRegularFileKey, .nameKey, .fileSizeKey],
+                options: [.skipsHiddenFiles]
+            )
+            
+            // Filter to only include regular files
+            let regularFileURLs = fileURLs.filter { url in
+                do {
+                    let resourceValues = try url.resourceValues(forKeys: [.isRegularFileKey])
+                    return resourceValues.isRegularFile ?? false
+                } catch {
+                    return false
+                }
+            }
+            
+            // Create FileResource objects for each file
+            return regularFileURLs.map { fileURL in
+                // Get file attributes for description
+                let fileAttributes: String
+                do {
+                    let attributes = try FileManager.default.attributesOfItem(atPath: fileURL.path)
+                    let fileSize = attributes[.size] as? Int64 ?? 0
+                    let modificationDate = attributes[.modificationDate] as? Date ?? Date()
+                    let formatter = DateFormatter()
+                    formatter.dateStyle = .medium
+                    formatter.timeStyle = .short
+                    fileAttributes = "Size: \(ByteCountFormatter.string(fromByteCount: fileSize, countStyle: .file)), Modified: \(formatter.string(from: modificationDate))"
+                } catch {
+                    fileAttributes = "File in Downloads folder"
+                }
+                
+                return FileResource(
+                    uri: fileURL,
+                    name: fileURL.lastPathComponent,
+                    description: fileAttributes
+                )
+            }
+        } catch {
+            logToStderr("Error listing files in Downloads folder: \(error)")
+            return []
+        }
+    }
+    
+    /// Gets a resource by URI
+    /// - Parameter uri: The URI of the resource to get
+    /// - Returns: The resource content, or nil if the resource doesn't exist
+    /// - Throws: MCPResourceError if there's an error getting the resource
+    func getResource(uri: URL) throws -> MCPResourceContent? {
+        // Check if the file exists
+        guard FileManager.default.fileExists(atPath: uri.path) else {
+            return nil
+        }
+        
+        // Get the resource content
+        return try FileResourceContent.from(fileURL: uri)
+    }
+    
+    /// Function to log a message to stderr
+    private func logToStderr(_ message: String) {
+        fputs("\(message)\n", stderr)
+    }
 }