Fix HumanInTheMiddleWrapper.getDummyArgsFor passing null for Project constructor arg (#302)

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: jGauravGupta <15934072+jGauravGupta@users.noreply.github.com>

Author: jGauravGupta

src/main/java/io/github/jeddict/ai/agent/HumanInTheMiddleWrapper.java

@@ -26,6 +26,7 @@
 import net.bytebuddy.matcher.ElementMatchers;
 
 import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.Arrays;
 import java.util.function.Function;
@@ -112,13 +113,13 @@ public <T> T wrap(T originalTool) {
                     .load(clazz.getClassLoader())
                     .getLoaded()
                     .getConstructor(clazz.getDeclaredConstructors()[0].getParameterTypes())
-                    .newInstance(getDummyArgsFor(clazz.getDeclaredConstructors()[0]));
+                    .newInstance(getDummyArgsFor(clazz.getDeclaredConstructors()[0], originalTool));
         } catch (Exception e) {
             throw new RuntimeException("Failed to wrap tool", e);
         }
     }
 
-    private Object[] getDummyArgsFor(Constructor<?> constructor) {
+    private Object[] getDummyArgsFor(Constructor<?> constructor, Object originalTool) {
         Object[] dummyArgs = new Object[constructor.getParameterCount()];
         Class<?>[] parameterTypes = constructor.getParameterTypes();
         for (int i = 0; i < parameterTypes.length; i++) {
@@ -128,12 +129,44 @@ private Object[] getDummyArgsFor(Constructor<?> constructor) {
             } else if (parameterTypes[i] == String.class) {
                 dummyArgs[i] = "."; // Satisfy AbstractTool's non-null basedir check
             } else {
-                dummyArgs[i] = null;
+                // For any other object parameter, try to get the actual value from
+                // the original tool via reflection so that the proxy subclass
+                // constructor does not fail on validation (e.g. ProjectTools(Project)
+                // calls basedirOf(project) which throws when project is null).
+                dummyArgs[i] = getFieldValueByType(parameterTypes[i], originalTool);
             }
         }
         return dummyArgs;
     }
 
+    /**
+     * Searches the class hierarchy of {@code source} for the first field whose
+     * type is assignable to {@code type} and returns its value.  Returns
+     * {@code null} when no matching field is found or the field is inaccessible.
+     *
+     * <p>The check {@code type.isAssignableFrom(field.getType())} answers:
+     * "can a value of {@code field.getType()} be used where {@code type} is
+     * expected?" — i.e. the field's declared type is the same as or a subtype
+     * of the required parameter type.</p>
+     */
+    private Object getFieldValueByType(Class<?> type, Object source) {
+        Class<?> clazz = source.getClass();
+        while (clazz != null) {
+            for (Field field : clazz.getDeclaredFields()) {
+                if (type.isAssignableFrom(field.getType())) {
+                    try {
+                        field.setAccessible(true);
+                        return field.get(source);
+                    } catch (IllegalAccessException | SecurityException ignored) {
+                        // fall through to the next field / superclass
+                    }
+                }
+            }
+            clazz = clazz.getSuperclass();
+        }
+        return null;
+    }
+
     /**
      * The Byte Buddy interceptor that contains the core HITM logic.
      */

src/test/java/io/github/jeddict/ai/agent/HumanInTheMiddleWrapperProjectTest.java

@@ -0,0 +1,71 @@
+/**
+ * Copyright 2025 the original author or authors from the Jeddict project (https://jeddict.github.io/).
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package io.github.jeddict.ai.agent;
+
+import com.github.caciocavallosilano.cacio.ctc.junit.CacioTest;
+import dev.langchain4j.agent.tool.ToolExecutionRequest;
+import io.github.jeddict.ai.agent.project.MavenProjectTools;
+import io.github.jeddict.ai.agent.project.ProjectTools;
+import io.github.jeddict.ai.test.TestBase;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Function;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.BDDAssertions.then;
+
+/**
+ * Regression tests for {@link HumanInTheMiddleWrapper} wrapping project-aware
+ * tools whose constructors take {@code Project} (rather than a plain
+ * {@code String} basedir).  These tests require a headless AWT environment
+ * (hence {@code @CacioTest}).
+ */
+@CacioTest
+public class HumanInTheMiddleWrapperProjectTest extends TestBase {
+
+    private List<ToolExecutionRequest> interceptionEvents;
+    private Function<ToolExecutionRequest, Boolean> interceptor;
+
+    @BeforeEach
+    @Override
+    public void beforeEach() throws Exception {
+        super.beforeEach();
+        interceptionEvents = new ArrayList<>();
+        interceptor = execution -> {
+            interceptionEvents.add(execution);
+            return true;
+        };
+    }
+
+    @Test
+    void wrapping_ProjectTools_does_not_throw() throws Exception {
+        // Regression: wrapping a ProjectTools (whose constructor takes a Project
+        // and calls basedirOf(project)) must not throw
+        // "IllegalArgumentException: project cannot be null".
+        final ProjectTools original = ProjectTools.forProject(project(projectDir));
+        final ProjectTools wrapped = new HumanInTheMiddleWrapper(interceptor).wrap(original);
+        then(wrapped).isNotNull();
+    }
+
+    @Test
+    void wrapping_MavenProjectTools_does_not_throw() throws Exception {
+        // Same regression check for the MavenProjectTools subclass.
+        final MavenProjectTools original = new MavenProjectTools(project(projectDir));
+        final MavenProjectTools wrapped = new HumanInTheMiddleWrapper(interceptor).wrap(original);
+        then(wrapped).isNotNull();
+    }
+}