refactor(server): Enhance parameter conversion in McpServerPromptFactory and McpServerToolFactory with dedicated converters

Author: codeboyzhou

src/main/java/com/github/codeboyzhou/mcp/declarative/di/DependencyInjectorProvider.java

@@ -6,9 +6,11 @@ public enum DependencyInjectorProvider {
   private volatile DependencyInjector injector;
 
   public DependencyInjectorProvider initialize(DependencyInjector injector) {
-    synchronized (this) {
-      if (this.injector == null) {
-        this.injector = injector;
+    if (this.injector == null) {
+      synchronized (this) {
+        if (this.injector == null) {
+          this.injector = injector;
+        }
       }
     }
     return this;

src/main/java/com/github/codeboyzhou/mcp/declarative/di/GuiceDependencyInjector.java

@@ -20,16 +20,16 @@ public <T> T getInstance(Class<T> type) {
     throw new IllegalStateException("GuiceDependencyInjector is not initialized");
   }
 
-  @Override
-  public boolean isInitialized() {
-    return injector != null;
-  }
-
   @Override
   public <T> T getVariable(Class<T> type, String name) {
     if (isInitialized()) {
       return injector.getInstance(Key.get(type, Names.named(name)));
     }
     throw new IllegalStateException("GuiceDependencyInjector is not initialized");
   }
+
+  @Override
+  public boolean isInitialized() {
+    return injector != null;
+  }
 }

src/main/java/com/github/codeboyzhou/mcp/declarative/di/GuiceInjectorModule.java

@@ -13,6 +13,8 @@
 import com.github.codeboyzhou.mcp.declarative.server.component.McpServerPromptFactory;
 import com.github.codeboyzhou.mcp.declarative.server.component.McpServerResourceFactory;
 import com.github.codeboyzhou.mcp.declarative.server.component.McpServerToolFactory;
+import com.github.codeboyzhou.mcp.declarative.server.converter.McpPromptParameterConverter;
+import com.github.codeboyzhou.mcp.declarative.server.converter.McpToolParameterConverter;
 import com.github.codeboyzhou.mcp.declarative.server.factory.McpSseServerFactory;
 import com.github.codeboyzhou.mcp.declarative.server.factory.McpStdioServerFactory;
 import com.github.codeboyzhou.mcp.declarative.server.factory.McpStreamableServerFactory;
@@ -47,6 +49,10 @@ protected void configure() {
     bind(McpServerPromptFactory.class).in(SINGLETON);
     bind(McpServerToolFactory.class).in(SINGLETON);
 
+    // Bind all implementations of ParameterConverter
+    bind(McpPromptParameterConverter.class).in(SINGLETON);
+    bind(McpToolParameterConverter.class).in(SINGLETON);
+
     // Bind all implementations of McpServerFactory
     bind(McpStdioServerFactory.class).in(SINGLETON);
     bind(McpSseServerFactory.class).in(SINGLETON);

src/main/java/com/github/codeboyzhou/mcp/declarative/server/component/McpServerPromptFactory.java

@@ -4,9 +4,9 @@
 import com.github.codeboyzhou.mcp.declarative.annotation.McpPromptParam;
 import com.github.codeboyzhou.mcp.declarative.reflect.MethodMetadata;
 import com.github.codeboyzhou.mcp.declarative.reflect.ReflectionCache;
+import com.github.codeboyzhou.mcp.declarative.server.converter.McpPromptParameterConverter;
 import com.github.codeboyzhou.mcp.declarative.util.ObjectMappers;
 import com.github.codeboyzhou.mcp.declarative.util.Strings;
-import com.github.codeboyzhou.mcp.declarative.util.Types;
 import io.modelcontextprotocol.server.McpServerFeatures;
 import io.modelcontextprotocol.spec.McpSchema;
 import java.lang.reflect.Method;
@@ -40,15 +40,18 @@ public McpServerFeatures.SyncPromptSpecification create(Class<?> clazz, Method m
         ObjectMappers.toJson(prompt),
         ReflectionCache.INSTANCE.isCached(method));
 
+    Object instance = injector.getInstance(clazz);
+    McpPromptParameterConverter converter = injector.getInstance(McpPromptParameterConverter.class);
+
     return new McpServerFeatures.SyncPromptSpecification(
         prompt,
         (exchange, request) -> {
           Object result;
           try {
-            Object instance = injector.getInstance(clazz);
-            List<Object> typedValues = asTypedParameters(metadata, request.arguments());
+            Map<String, Object> arguments = request.arguments();
+            List<Object> convertedParams = converter.convertAllParameters(metadata, arguments);
             // Use cached method for invocation
-            result = metadata.getMethod().invoke(instance, typedValues.toArray());
+            result = metadata.getMethod().invoke(instance, convertedParams.toArray());
           } catch (Exception e) {
             log.error("Error invoking prompt method {}", metadata.getMethodSignature(), e);
             result = e + ": " + e.getMessage();
@@ -77,24 +80,4 @@ private List<McpSchema.PromptArgument> createPromptArguments(MethodMetadata meta
 
     return promptArguments;
   }
-
-  private List<Object> asTypedParameters(MethodMetadata metadata, Map<String, Object> arguments) {
-    Parameter[] methodParams = metadata.getParameters();
-    List<Object> typedValues = new ArrayList<>(methodParams.length);
-
-    for (Parameter param : methodParams) {
-      Object rawValue = null;
-      if (param.isAnnotationPresent(McpPromptParam.class)) {
-        McpPromptParam promptParam = param.getAnnotation(McpPromptParam.class);
-        rawValue = arguments.get(promptParam.name());
-      }
-      // Fill in a default value when the parameter is not specified or unannotated
-      // to ensure that the parameter type is correct when calling method.invoke()
-      Class<?> targetType = param.getType();
-      Object typedValue = Types.convert(rawValue, targetType);
-      typedValues.add(typedValue);
-    }
-
-    return typedValues;
-  }
 }

src/main/java/com/github/codeboyzhou/mcp/declarative/server/component/McpServerToolFactory.java

@@ -7,9 +7,9 @@
 import com.github.codeboyzhou.mcp.declarative.enums.JsonSchemaDataType;
 import com.github.codeboyzhou.mcp.declarative.reflect.MethodMetadata;
 import com.github.codeboyzhou.mcp.declarative.reflect.ReflectionCache;
+import com.github.codeboyzhou.mcp.declarative.server.converter.McpToolParameterConverter;
 import com.github.codeboyzhou.mcp.declarative.util.ObjectMappers;
 import com.github.codeboyzhou.mcp.declarative.util.Strings;
-import com.github.codeboyzhou.mcp.declarative.util.Types;
 import io.modelcontextprotocol.server.McpServerFeatures;
 import io.modelcontextprotocol.spec.McpSchema;
 import java.lang.reflect.Field;
@@ -54,17 +54,20 @@ public McpServerFeatures.SyncToolSpecification create(Class<?> clazz, Method met
         ObjectMappers.toJson(tool),
         ReflectionCache.INSTANCE.isCached(method));
 
+    Object instance = injector.getInstance(clazz);
+    McpToolParameterConverter converter = injector.getInstance(McpToolParameterConverter.class);
+
     return McpServerFeatures.SyncToolSpecification.builder()
         .tool(tool)
         .callHandler(
             (exchange, request) -> {
               Object result;
               boolean isError = false;
               try {
-                Object instance = injector.getInstance(clazz);
-                List<Object> typedValues = asTypedParameters(metadata, request.arguments());
+                Map<String, Object> arguments = request.arguments();
+                List<Object> convertedParams = converter.convertAllParameters(metadata, arguments);
                 // Use cached method for invocation
-                result = metadata.getMethod().invoke(instance, typedValues.toArray());
+                result = metadata.getMethod().invoke(instance, convertedParams.toArray());
               } catch (Exception e) {
                 log.error("Error invoking tool method {}", metadata.getMethodSignature(), e);
                 result = e + ": " + e.getMessage();
@@ -153,24 +156,4 @@ private Map<String, Object> createJsonSchemaDefinition(Class<?> definitionClass)
 
     return definitionJsonSchema;
   }
-
-  private List<Object> asTypedParameters(MethodMetadata metadata, Map<String, Object> arguments) {
-    Parameter[] methodParams = metadata.getParameters();
-    List<Object> typedValues = new ArrayList<>(methodParams.length);
-
-    for (Parameter param : methodParams) {
-      Object rawValue = null;
-      if (param.isAnnotationPresent(McpToolParam.class)) {
-        McpToolParam toolParam = param.getAnnotation(McpToolParam.class);
-        rawValue = arguments.get(toolParam.name());
-      }
-      // Fill in a default value when the parameter is not specified or unannotated
-      // to ensure that the parameter type is correct when calling method.invoke()
-      Class<?> targetType = param.getType();
-      Object typedValue = Types.convert(rawValue, targetType);
-      typedValues.add(typedValue);
-    }
-
-    return typedValues;
-  }
 }

src/main/java/com/github/codeboyzhou/mcp/declarative/server/converter/AbstractParameterConverter.java

@@ -0,0 +1,33 @@
+package com.github.codeboyzhou.mcp.declarative.server.converter;
+
+import com.github.codeboyzhou.mcp.declarative.reflect.MethodMetadata;
+import com.github.codeboyzhou.mcp.declarative.util.Types;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Parameter;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public abstract class AbstractParameterConverter<A extends Annotation>
+    implements ParameterConverter<A> {
+
+  public List<Object> convertAllParameters(MethodMetadata metadata, Map<String, Object> args) {
+    Parameter[] params = metadata.getParameters();
+    List<Object> result = new ArrayList<>(params.length);
+
+    for (Parameter param : params) {
+      A annotation = param.getAnnotation(getAnnotationType());
+      Object converted;
+      // Fill in a default value when the parameter is not specified or unannotated
+      // to ensure that the parameter type is correct when calling method.invoke()
+      if (annotation == null) {
+        converted = Types.convert(null, param.getType());
+      } else {
+        converted = convert(param, annotation, args);
+      }
+      result.add(converted);
+    }
+
+    return result;
+  }
+}

src/main/java/com/github/codeboyzhou/mcp/declarative/server/converter/McpPromptParameterConverter.java

@@ -0,0 +1,19 @@
+package com.github.codeboyzhou.mcp.declarative.server.converter;
+
+import com.github.codeboyzhou.mcp.declarative.annotation.McpPromptParam;
+import com.github.codeboyzhou.mcp.declarative.util.Types;
+import java.lang.reflect.Parameter;
+import java.util.Map;
+
+public class McpPromptParameterConverter extends AbstractParameterConverter<McpPromptParam> {
+  @Override
+  public Object convert(Parameter parameter, McpPromptParam annotation, Map<String, Object> args) {
+    Object rawValue = args.get(annotation.name());
+    return Types.convert(rawValue, parameter.getType());
+  }
+
+  @Override
+  public Class<McpPromptParam> getAnnotationType() {
+    return McpPromptParam.class;
+  }
+}

src/main/java/com/github/codeboyzhou/mcp/declarative/server/converter/McpToolParameterConverter.java

@@ -0,0 +1,19 @@
+package com.github.codeboyzhou.mcp.declarative.server.converter;
+
+import com.github.codeboyzhou.mcp.declarative.annotation.McpToolParam;
+import com.github.codeboyzhou.mcp.declarative.util.Types;
+import java.lang.reflect.Parameter;
+import java.util.Map;
+
+public class McpToolParameterConverter extends AbstractParameterConverter<McpToolParam> {
+  @Override
+  public Object convert(Parameter parameter, McpToolParam annotation, Map<String, Object> args) {
+    Object rawValue = args.get(annotation.name());
+    return Types.convert(rawValue, parameter.getType());
+  }
+
+  @Override
+  public Class<McpToolParam> getAnnotationType() {
+    return McpToolParam.class;
+  }
+}

src/main/java/com/github/codeboyzhou/mcp/declarative/server/converter/ParameterConverter.java

@@ -0,0 +1,11 @@
+package com.github.codeboyzhou.mcp.declarative.server.converter;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Parameter;
+import java.util.Map;
+
+public interface ParameterConverter<A extends Annotation> {
+  Object convert(Parameter parameter, A annotation, Map<String, Object> args);
+
+  Class<A> getAnnotationType();
+}