Now with async support the MCPServer can also be an actor

Author: odrobnik

Demos/SwiftMCPDemo/Calculator.swift

@@ -5,7 +5,7 @@ import SwiftMCP
  A Calculator for simple math doing additionals, subtractions etc.
  */
 @MCPServer(name: "SwiftMCP Demo")
-class Calculator {
+actor Calculator {
     /// Adds two integers and returns their sum
     /// - Parameter a: First number to add
     /// - Parameter b: Second number to add

Sources/SwiftMCP/Protocols/MCPServer.swift

@@ -7,10 +7,10 @@ public protocol MCPServer: AnyObject {
     var mcpTools: [MCPTool] { get }
 
     /// Returns an array of all MCP resources defined in this type
-    var mcpResources: [MCPResource] { get }
+    var mcpResources: [MCPResource] { get async }
 
 	/// Returns an array of all MCP resource templates defined in this type
-	var mcpResourceTemplates: [MCPResourceTemplate] { get }
+	var mcpResourceTemplates: [MCPResourceTemplate] { get async }
 
 
     /// Calls a tool by name with the provided arguments
@@ -25,7 +25,7 @@ public protocol MCPServer: AnyObject {
     /// - 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?
+    func getResource(uri: URL) async throws -> MCPResourceContent?
 
     /// Handles a JSON-RPC request
     /// - Parameter request: The JSON-RPC request to handle
@@ -62,13 +62,13 @@ public extension MCPServer {
                 return createToolsResponse(id: request.id ?? 0)
 
             case "resources/list":
-                return createResourcesListResponse(id: request.id ?? 0)
+                return await createResourcesListResponse(id: request.id ?? 0)
 
             case "resources/templates/list":
-                return createResourceTemplatesListResponse(id: request.id ?? 0)
+                return await createResourceTemplatesListResponse(id: request.id ?? 0)
 
             case "resources/read":
-                return createResourcesReadResponse(id: request.id ?? 0, request: request)
+                return await createResourcesReadResponse(id: request.id ?? 0, request: request)
 
             case "tools/call":
                 return await handleToolCall(request)
@@ -101,9 +101,9 @@ public extension MCPServer {
     /// Creates a resources list response
     /// - Parameter id: The request ID
     /// - Returns: The resources list response
-    func createResourcesListResponse(id: Int) -> JSONRPC.Response {
+    func createResourcesListResponse(id: Int) async -> JSONRPC.Response {
         // Convert MCPResource objects to dictionaries
-        let resourceDicts = mcpResources.map { resource -> [String: Any] in
+        let resourceDicts = await mcpResources.map { resource -> [String: Any] in
             return [
                 "uri": resource.uri.absoluteString,
                 "name": resource.name,
@@ -194,7 +194,7 @@ public extension MCPServer {
     ///   - id: The request ID
     ///   - request: The original JSON-RPC request
     /// - Returns: The resources read response
-    func createResourcesReadResponse(id: Int, request: JSONRPCRequest) -> JSONRPC.Response {
+    func createResourcesReadResponse(id: Int, request: JSONRPCRequest) async -> JSONRPC.Response {
         // Extract the URI from the request params
         guard let uriString = request.params?["uri"]?.value as? String,
               let uri = URL(string: uriString) else {
@@ -207,7 +207,7 @@ public extension MCPServer {
 
         do {
             // Try to get the resource content
-            if let resourceContent = try getResource(uri: uri) {
+            if let resourceContent = try await getResource(uri: uri) {
                 // Convert MCPResourceContent to dictionary
                 var contentDict: [String: Any] = [
                     "uri": resourceContent.uri.absoluteString
@@ -252,9 +252,9 @@ public extension MCPServer {
     /// Creates a resource templates list response
     /// - Parameter id: The request ID
     /// - Returns: The resource templates list response
-    func createResourceTemplatesListResponse(id: Int) -> JSONRPC.Response {
+    func createResourceTemplatesListResponse(id: Int) async -> JSONRPC.Response {
         // Convert MCPResourceTemplate objects to dictionaries
-        let templateDicts = mcpResourceTemplates.map { template -> [String: Any] in
+        let templateDicts = await mcpResourceTemplates.map { template -> [String: Any] in
             return [
                 "uriTemplate": template.uriTemplate.absoluteString,
                 "name": template.name,
@@ -296,7 +296,7 @@ public extension MCPServer {
 	}
 
 	/// Default implementation
-	func getResource(uri: URL) throws -> MCPResourceContent? {
+	func getResource(uri: URL) async throws -> MCPResourceContent? {
 		return nil
 	}
 

Sources/SwiftMCPMacros/MCPServerDiagnostics.swift

@@ -12,26 +12,26 @@ import SwiftSyntaxMacros
  */
 enum MCPServerDiagnostic: DiagnosticMessage {
 	/// Error when the macro is applied to a non-class declaration
-	case requiresClass(typeName: String, actualType: String)
+	case requiresReferenceType(typeName: String)
 
 	var message: String {
 		switch self {
-			case .requiresClass(let typeName, let actualType):
-				return "MCPServer can only be applied to classes, but '\(typeName)' is a \(actualType)"
+			case .requiresReferenceType(let typeName):
+				return "'\(typeName)' must be a reference type (class or actor)"
 		}
 	}
 
 	var severity: DiagnosticSeverity {
 		switch self {
-			case .requiresClass:
+			case .requiresReferenceType:
 				return .error
 		}
 	}
 
 	var diagnosticID: MessageID {
 		switch self {
-			case .requiresClass:
-				return MessageID(domain: "SwiftMCP", id: "requiresClass")
+			case .requiresReferenceType:
+				return MessageID(domain: "SwiftMCPMacros", id: "RequiresReferenceType")
 		}
 	}
 }
@@ -43,14 +43,14 @@ enum MCPServerFixItMessage: FixItMessage {
 	var message: String {
 		switch self {
 			case .replaceWithClass(let keyword):
-				return "Replace '\(keyword)' with 'class'"
+				return "Change '\(keyword)' to 'class'"
 		}
 	}
 
 	var fixItID: MessageID {
 		switch self {
 			case .replaceWithClass:
-				return MessageID(domain: "SwiftMCP", id: "replaceWithClass")
+				return MessageID(domain: "SwiftMCPMacros", id: "ReplaceWithClass")
 		}
 	}
 } 

Sources/SwiftMCPMacros/MCPServerMacro.swift

@@ -14,7 +14,7 @@ import SwiftDiagnostics
 /**
  Implementation of the MCPServer macro.
 
- This macro adds MCPServer protocol conformance to a class and generates the necessary
+ This macro adds MCPServer protocol conformance and generates the necessary
  infrastructure for handling MCP tools.
 
  Example usage:
@@ -29,14 +29,28 @@ import SwiftDiagnostics
  }
  ```
 
- - Note: The server description is automatically extracted from the class's documentation comment.
+ Or with an actor:
+ ```swift
+ /// A server that provides calculator functionality
+ @MCPServer(
+     name: "calculator",
+     version: "1.0"
+ )
+ actor CalculatorServer {
+     // MCP tool functions go here
+ }
+ ```
+ 
+ - Note: The server description is automatically extracted from the documentation comment.
 
  - Parameters:
-   - name: The name of the server. Defaults to the class name.
+   - name: The name of the server. Defaults to the declaration name.
    - version: The version of the server. Defaults to "1.0".
 
- - Attention: This macro can only be applied to classes. Using it on a struct or actor
-             will result in a diagnostic with a fix-it to convert to a class.
+ - Throws: MCPToolError if a tool cannot be found or called
+ 
+ - Attention: This macro can only be applied to reference types (classes or actors).
+             Using it on a struct will result in a diagnostic with a fix-it to convert to a class.
  */
 public struct MCPServerMacro: MemberMacro, ExtensionMacro {
 	/**
@@ -54,44 +68,24 @@ public struct MCPServerMacro: MemberMacro, ExtensionMacro {
 		providingMembersOf declaration: some DeclGroupSyntax,
 		in context: some MacroExpansionContext
 	) throws -> [DeclSyntax] {
-		// Check if the declaration is a class
-		guard declaration.is(ClassDeclSyntax.self) else {
-			// If it's a struct or actor, emit a diagnostic with a fix-it
-			if let structDecl = declaration.as(StructDeclSyntax.self) {
-				let diagnostic = SwiftDiagnostics.Diagnostic(
-					node: Syntax(structDecl.structKeyword),
-					message: MCPServerDiagnostic.requiresClass(typeName: structDecl.name.text, actualType: "struct"),
-					fixIts: [
-						FixIt(
-							message: MCPServerFixItMessage.replaceWithClass(keyword: "struct"),
-							changes: [
-								.replace(
-									oldNode: Syntax(structDecl.structKeyword),
-									newNode: Syntax(TokenSyntax.keyword(.class))
-								)
-							]
-						)
-					]
-				)
-				context.diagnose(diagnostic)
-			} else if let actorDecl = declaration.as(ActorDeclSyntax.self) {
-				let diagnostic = SwiftDiagnostics.Diagnostic(
-					node: Syntax(actorDecl.actorKeyword),
-					message: MCPServerDiagnostic.requiresClass(typeName: actorDecl.name.text, actualType: "actor"),
-					fixIts: [
-						FixIt(
-							message: MCPServerFixItMessage.replaceWithClass(keyword: "actor"),
-							changes: [
-								.replace(
-									oldNode: Syntax(actorDecl.actorKeyword),
-									newNode: Syntax(TokenSyntax.keyword(.class))
-								)
-							]
-						)
-					]
-				)
-				context.diagnose(diagnostic)
-			}
+		// Check if the declaration is a class or actor
+		if let structDecl = declaration.as(StructDeclSyntax.self) {
+			let diagnostic = SwiftDiagnostics.Diagnostic(
+				node: Syntax(structDecl.structKeyword),
+				message: MCPServerDiagnostic.requiresReferenceType(typeName: structDecl.name.text),
+				fixIts: [
+					FixIt(
+						message: MCPServerFixItMessage.replaceWithClass(keyword: "struct"),
+						changes: [
+							.replace(
+								oldNode: Syntax(structDecl.structKeyword),
+								newNode: Syntax(TokenSyntax.keyword(.class))
+							)
+						]
+					)
+				]
+			)
+			context.diagnose(diagnostic)
 			return []
 		}
 

Sources/SwiftMCPMacros/MCPToolMacro.swift

@@ -250,7 +250,7 @@ public struct MCPToolMacro: PeerMacro {
 		var wrapperMethod = """
 		
 		/// Autogenerated wrapper for \(functionName) that takes a dictionary of parameters
-		nonisolated func __mcpCall_\(functionName)(_ params: [String: Any]) async throws -> Codable {
+		func __mcpCall_\(functionName)(_ params: [String: Any]) async throws -> Codable {
 		"""
 
 		// Add parameter extraction code