feat(config): Adds resolveAgentClass, resolveToolInstance and resolveToolClass to ComponentRegistry for resolving the 3 type of components

Uses `resolveAgentClass` in ConfigAgentUtils and `resolveToolInstance` in LlmAgent.

PiperOrigin-RevId: 795272083

Author: Jacksunwei

core/src/main/java/com/google/adk/agents/ConfigAgentUtils.java

@@ -16,11 +16,10 @@
 
 package com.google.adk.agents;
 
-import static com.google.common.base.Strings.isNullOrEmpty;
-
 import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;
+import com.google.adk.utils.ComponentRegistry;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
@@ -59,7 +58,8 @@ public static BaseAgent fromConfig(String configPath) throws ConfigurationExcept
     try {
       // Load the base config to determine the agent class
       BaseAgentConfig baseConfig = loadConfigAsType(absolutePath, BaseAgentConfig.class);
-      Class<? extends BaseAgent> agentClass = resolveAgentClass(baseConfig.agentClass());
+      Class<? extends BaseAgent> agentClass =
+          ComponentRegistry.resolveAgentClass(baseConfig.agentClass());
 
       // Load the config file with the specific config class
       Class<? extends BaseAgentConfig> configClass = getConfigClassForAgent(agentClass);
@@ -97,32 +97,6 @@ private static <T extends BaseAgentConfig> T loadConfigAsType(
     }
   }
 
-  /**
-   * Resolves the agent class based on the agent class name from the configuration.
-   *
-   * @param agentClassName the name of the agent class from the config
-   * @return the corresponding agent class
-   * @throws ConfigurationException if the agent class is not supported
-   */
-  private static Class<? extends BaseAgent> resolveAgentClass(String agentClassName)
-      throws ConfigurationException {
-    // If no agent_class is specified in the yaml file, it will default to LlmAgent.
-    if (isNullOrEmpty(agentClassName) || agentClassName.equals("LlmAgent")) {
-      return LlmAgent.class;
-    }
-
-    // TODO: Support more agent classes
-    // Example for future extensions:
-    // if (agentClassName.equals("CustomAgent")) {
-    //   return CustomAgent.class;
-    // }
-
-    throw new ConfigurationException(
-        "agentClass '"
-            + agentClassName
-            + "' is not supported. It must be a subclass of BaseAgent.");
-  }
-
   /**
    * Maps agent classes to their corresponding config classes.
    *

core/src/main/java/com/google/adk/agents/LlmAgent.java

@@ -16,6 +16,7 @@
 
 package com.google.adk.agents;
 
+import static com.google.common.base.Strings.isNullOrEmpty;
 import static com.google.common.base.Strings.nullToEmpty;
 import static java.util.stream.Collectors.joining;
 
@@ -53,7 +54,7 @@
 import com.google.adk.tools.BaseTool;
 import com.google.adk.tools.BaseTool.ToolConfig;
 import com.google.adk.tools.BaseToolset;
-import com.google.common.base.CaseFormat;
+import com.google.adk.utils.ComponentRegistry;
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
@@ -63,7 +64,6 @@
 import io.reactivex.rxjava3.core.Flowable;
 import io.reactivex.rxjava3.core.Maybe;
 import io.reactivex.rxjava3.core.Single;
-import java.lang.reflect.Constructor;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
@@ -950,23 +950,21 @@ private static ImmutableList<BaseTool> resolveTools(
 
     for (ToolConfig toolConfig : toolConfigs) {
       try {
-        String toolName = toolConfig.name();
-        if (toolName == null || toolName.trim().isEmpty()) {
+        if (isNullOrEmpty(toolConfig.name())) {
           throw new ConfigurationException("Tool name cannot be empty");
         }
 
-        toolName = toolName.trim();
-        BaseTool tool;
-
-        if (!toolName.contains(".")) {
-          tool = resolveBuiltInTool(toolName, toolConfig);
+        String toolName = toolConfig.name().trim();
+        Optional<BaseTool> toolOpt = ComponentRegistry.resolveToolInstance(toolName);
+        if (toolOpt.isPresent()) {
+          resolvedTools.add(toolOpt.get());
         } else {
           // TODO: Support user-defined tools
+          // TODO: Support using tool class via ComponentRegistry.resolveToolClass
           logger.debug("configAbsPath is: {}", configAbsPath);
-          throw new ConfigurationException("User-defined tools are not yet supported");
+          throw new ConfigurationException("Tool not found: " + toolName);
         }
 
-        resolvedTools.add(tool);
         logger.debug("Successfully resolved tool: {}", toolConfig.name());
       } catch (Exception e) {
         String errorMsg = "Failed to resolve tool: " + toolConfig.name();
@@ -977,77 +975,4 @@ private static ImmutableList<BaseTool> resolveTools(
 
     return ImmutableList.copyOf(resolvedTools);
   }
-
-  private static BaseTool resolveBuiltInTool(String toolName, ToolConfig toolConfig)
-      throws ConfigurationException {
-    try {
-      logger.debug("Resolving built-in tool: {}", toolName);
-      // TODO: Handle built-in tool name end with Tool while config yaml file does not.
-      // e.g.google_search in config yaml file and GoogleSearchTool in tool class name.
-      String pascalCaseToolName = CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL, toolName);
-      String className = "com.google.adk.tools." + pascalCaseToolName;
-      Class<?> toolClass;
-      try {
-        toolClass = Class.forName(className);
-        logger.debug("Successfully loaded tool class: {}", className);
-      } catch (ClassNotFoundException e) {
-        String fallbackClassName = "com.google.adk.tools." + toolName;
-        try {
-          toolClass = Class.forName(fallbackClassName);
-        } catch (ClassNotFoundException e2) {
-          throw new ConfigurationException(
-              "Built-in tool not found: "
-                  + toolName
-                  + ". Expected class: "
-                  + className
-                  + " or "
-                  + fallbackClassName,
-              e2);
-        }
-      }
-
-      if (!BaseTool.class.isAssignableFrom(toolClass)) {
-        throw new ConfigurationException(
-            "Built-in tool class " + toolClass.getName() + " does not extend BaseTool");
-      }
-
-      @SuppressWarnings("unchecked")
-      Class<? extends BaseTool> baseToolClass = (Class<? extends BaseTool>) toolClass;
-
-      BaseTool tool = createToolInstance(baseToolClass, toolConfig);
-      logger.info(
-          "Successfully created built-in tool: {} (class: {})", toolName, toolClass.getName());
-
-      return tool;
-
-    } catch (Exception e) {
-      logger.error("Failed to create built-in tool: {}", toolName, e);
-      throw new ConfigurationException("Failed to create built-in tool: " + toolName, e);
-    }
-  }
-
-  private static BaseTool createToolInstance(
-      Class<? extends BaseTool> toolClass, ToolConfig toolConfig)
-      throws ConfigAgentUtils.ConfigurationException {
-
-    try {
-      // TODO:implement constructor with ToolArgsConfig
-      logger.debug("ToolConfig is: {}", toolConfig);
-
-      // Try default constructor
-      try {
-        Constructor<? extends BaseTool> constructor = toolClass.getConstructor();
-        return constructor.newInstance();
-      } catch (NoSuchMethodException e) {
-        // Continue
-      }
-
-      throw new ConfigAgentUtils.ConfigurationException(
-          "No suitable constructor found for tool class: " + toolClass.getName());
-
-    } catch (Exception e) {
-      throw new ConfigAgentUtils.ConfigurationException(
-          "Failed to instantiate tool class: " + toolClass.getName(), e);
-    }
-  }
 }

core/src/main/java/com/google/adk/utils/ComponentRegistry.java

@@ -16,11 +16,21 @@
 
 package com.google.adk.utils;
 
-import com.google.adk.tools.BuiltInCodeExecutionTool;
+import static com.google.common.base.Strings.isNullOrEmpty;
+
+import com.google.adk.agents.BaseAgent;
+import com.google.adk.agents.LlmAgent;
+import com.google.adk.agents.LoopAgent;
+import com.google.adk.agents.ParallelAgent;
+import com.google.adk.agents.SequentialAgent;
+import com.google.adk.tools.AgentTool;
+import com.google.adk.tools.BaseTool;
 import com.google.adk.tools.GoogleSearchTool;
+import com.google.adk.tools.LoadArtifactsTool;
 import java.util.Map;
 import java.util.Optional;
 import java.util.concurrent.ConcurrentHashMap;
+import javax.annotation.Nonnull;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -74,18 +84,44 @@ public class ComponentRegistry {
 
   private final Map<String, Object> registry = new ConcurrentHashMap<>();
 
-  public ComponentRegistry() {
+  protected ComponentRegistry() {
     initializePreWiredEntries();
   }
 
   /** Initializes the registry with base pre-wired ADK instances. */
   private void initializePreWiredEntries() {
-    registry.put("google_search", new GoogleSearchTool());
-    registry.put("code_execution", new BuiltInCodeExecutionTool());
+    registerAdkAgentClass(LlmAgent.class);
+    registerAdkAgentClass(LoopAgent.class);
+    registerAdkAgentClass(ParallelAgent.class);
+    registerAdkAgentClass(SequentialAgent.class);
+
+    registerAdkToolInstance("google_search", new GoogleSearchTool());
+    registerAdkToolInstance("load_artifacts", new LoadArtifactsTool());
+
+    registerAdkToolClass(AgentTool.class);
+    // TODO: add all python tools that also exist in Java.
 
     logger.debug("Initialized base pre-wired entries in ComponentRegistry");
   }
 
+  private void registerAdkAgentClass(Class<? extends BaseAgent> agentClass) {
+    registry.put(agentClass.getName(), agentClass);
+    // For python compatibility, also register the name used in ADK Python.
+    registry.put("google.adk.agents." + agentClass.getSimpleName(), agentClass);
+  }
+
+  private void registerAdkToolInstance(String name, @Nonnull Object toolInstance) {
+    registry.put(name, toolInstance);
+    // For python compatibility, also register the name used in ADK Python.
+    registry.put("google.adk.tools." + name, toolInstance);
+  }
+
+  private void registerAdkToolClass(@Nonnull Class<?> toolClass) {
+    registry.put(toolClass.getName(), toolClass);
+    // For python compatibility, also register the name used in ADK Python.
+    registry.put("google.adk.tools." + toolClass.getSimpleName(), toolClass);
+  }
+
   /**
    * Registers an object with the given name. This can override pre-wired entries.
    *
@@ -182,4 +218,109 @@ public static synchronized void setInstance(ComponentRegistry newInstance) {
     instance = newInstance;
     logger.info("ComponentRegistry singleton instance updated");
   }
+
+  /**
+   * Resolves the agent class based on the agent class name from the configuration.
+   *
+   * @param agentClassName the name of the agent class from the config
+   * @return the corresponding agent class
+   * @throws IllegalArgumentException if the agent class is not supported
+   */
+  @SuppressWarnings({"unchecked", "rawtypes"}) // For type casting.
+  public static Class<? extends BaseAgent> resolveAgentClass(String agentClassName) {
+    // If no agent_class is specified, it will default to LlmAgent.
+    if (isNullOrEmpty(agentClassName)) {
+      return LlmAgent.class;
+    }
+
+    ComponentRegistry registry = getInstance();
+
+    if (agentClassName.contains(".")) {
+      // If agentClassName contains '.', use it directly
+      Optional<Class> agentClass = registry.get(agentClassName, Class.class);
+      if (agentClass.isPresent() && BaseAgent.class.isAssignableFrom(agentClass.get())) {
+        return (Class<? extends BaseAgent>) agentClass.get();
+      }
+    } else {
+      // First try the simple name
+      Optional<Class> agentClass = registry.get(agentClassName, Class.class);
+      if (agentClass.isPresent() && BaseAgent.class.isAssignableFrom(agentClass.get())) {
+        return (Class<? extends BaseAgent>) agentClass.get();
+      }
+
+      // If not found, try with com.google.adk.agents prefix
+      agentClass = registry.get("com.google.adk.agents." + agentClassName, Class.class);
+      if (agentClass.isPresent() && BaseAgent.class.isAssignableFrom(agentClass.get())) {
+        return (Class<? extends BaseAgent>) agentClass.get();
+      }
+    }
+
+    throw new IllegalArgumentException(
+        "agentClass '" + agentClassName + "' is not in registry or not a subclass of BaseAgent.");
+  }
+
+  /**
+   * Resolves the tool instance based on the tool name from the configuration.
+   *
+   * @param name the name of the tool from the config
+   * @return an Optional containing the tool instance if found, empty otherwise
+   */
+  public static Optional<BaseTool> resolveToolInstance(String name) {
+    if (isNullOrEmpty(name)) {
+      return Optional.empty();
+    }
+
+    ComponentRegistry registry = getInstance();
+
+    if (name.contains(".")) {
+      // If name contains '.', use it directly
+      return registry.get(name, BaseTool.class);
+    } else {
+      // First try the simple name
+      Optional<BaseTool> toolInstance = registry.get(name, BaseTool.class);
+      if (toolInstance.isPresent()) {
+        return toolInstance;
+      }
+
+      // If not found, try with google.adk.tools prefix
+      return registry.get("google.adk.tools." + name, BaseTool.class);
+    }
+  }
+
+  /**
+   * Resolves the tool class based on the tool class name from the configuration.
+   *
+   * @param toolClassName the name of the tool class from the config
+   * @return an Optional containing the tool class if found, empty otherwise
+   */
+  @SuppressWarnings({"unchecked", "rawtypes"}) // For type casting.
+  public static Optional<Class<? extends BaseTool>> resolveToolClass(String toolClassName) {
+    if (isNullOrEmpty(toolClassName)) {
+      return Optional.empty();
+    }
+
+    ComponentRegistry registry = getInstance();
+
+    if (toolClassName.contains(".")) {
+      // If toolClassName contains '.', use it directly
+      Optional<Class> toolClass = registry.get(toolClassName, Class.class);
+      if (toolClass.isPresent() && BaseTool.class.isAssignableFrom(toolClass.get())) {
+        return Optional.of((Class<? extends BaseTool>) toolClass.get());
+      }
+    } else {
+      // First try the simple name
+      Optional<Class> toolClass = registry.get(toolClassName, Class.class);
+      if (toolClass.isPresent() && BaseTool.class.isAssignableFrom(toolClass.get())) {
+        return Optional.of((Class<? extends BaseTool>) toolClass.get());
+      }
+
+      // If not found, try with google.adk.tools prefix
+      toolClass = registry.get("google.adk.tools." + toolClassName, Class.class);
+      if (toolClass.isPresent() && BaseTool.class.isAssignableFrom(toolClass.get())) {
+        return Optional.of((Class<? extends BaseTool>) toolClass.get());
+      }
+    }
+
+    return Optional.empty();
+  }
 }