fix confilct

Author: WastingTimeToThink

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

@@ -54,8 +54,8 @@
 import com.google.adk.tools.BaseTool.ToolArgsConfig;
 import com.google.adk.tools.BaseTool.ToolConfig;
 import com.google.adk.tools.BaseToolset;
-import com.google.adk.utils.ComponentRegistry;
 import com.google.adk.tools.internal.ToolConstraints;
+import com.google.adk.utils.ComponentRegistry;
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
@@ -613,14 +613,9 @@ protected void validate() {
     }
 
     public LlmAgent build() {
+      validate();
       LlmAgent built = new LlmAgent(this);
-      // New Guardrail Check
-      if (Boolean.getBoolean("adk.enableToolConstraints")) {
-        try {
-          ToolConstraints.validateAgentTree(built);
-        } catch (NullPointerException ignored) {
-        }
-      }
+      ToolConstraints.validateAgentTree(built);
       return built;
     }
   }
@@ -1190,307 +1185,4 @@ static BaseTool resolveInstanceViaReflection(String toolName) throws Exception {
     }
     return null;
   }
-
-  /**
-   * Creates an LlmAgent from configuration.
-   *
-   * @param config the agent configuration
-   * @param configAbsPath The absolute path to the agent config file. This is needed for resolving
-   *     relative paths for e.g. tools.
-   * @return the configured LlmAgent
-   * @throws ConfigurationException if the configuration is invalid
-   *     <p>TODO: Config agent features are not yet ready for public use.
-   */
-  public static LlmAgent fromConfig(LlmAgentConfig config, String configAbsPath)
-      throws ConfigurationException {
-    logger.debug("Creating LlmAgent from config: {}", config.name());
-
-    // Validate required fields
-    if (config.name() == null || config.name().trim().isEmpty()) {
-      throw new ConfigurationException("Agent name is required");
-    }
-
-    if (config.instruction() == null || config.instruction().trim().isEmpty()) {
-      throw new ConfigurationException("Agent instruction is required");
-    }
-
-    // Create builder with required fields
-    Builder builder =
-        LlmAgent.builder()
-            .name(config.name())
-            .description(nullToEmpty(config.description()))
-            .instruction(config.instruction());
-
-    if (config.model() != null && !config.model().trim().isEmpty()) {
-      builder.model(config.model());
-    }
-
-    try {
-      if (config.tools() != null) {
-        builder.tools(resolveTools(config.tools(), configAbsPath));
-      }
-    } catch (ConfigurationException e) {
-      throw new ConfigurationException("Error resolving tools for agent " + config.name(), e);
-    }
-
-    // Set optional transfer configuration
-    if (config.disallowTransferToParent() != null) {
-      builder.disallowTransferToParent(config.disallowTransferToParent());
-    }
-
-    if (config.disallowTransferToPeers() != null) {
-      builder.disallowTransferToPeers(config.disallowTransferToPeers());
-    }
-
-    // Set optional output key
-    if (config.outputKey() != null && !config.outputKey().trim().isEmpty()) {
-      builder.outputKey(config.outputKey());
-    }
-
-    // Build and return the agent
-    LlmAgent agent = builder.build();
-    logger.info("Successfully created LlmAgent: {}", agent.name());
-
-    return agent;
-  }
-
-  /**
-   * Resolves a list of tool configurations into {@link BaseTool} instances.
-   *
-   * <p>This method is only for use by Agent Development Kit.
-   *
-   * @param toolConfigs The list of tool configurations to resolve.
-   * @param configAbsPath The absolute path to the agent config file currently being processed. This
-   *     path can be used to resolve relative paths for tool configurations, if necessary.
-   * @return An immutable list of resolved {@link BaseTool} instances.
-   * @throws ConfigurationException if any tool configuration is invalid (e.g., missing name), if a
-   *     tool cannot be found by its name or class, or if tool instantiation fails.
-   */
-  static ImmutableList<BaseTool> resolveTools(List<ToolConfig> toolConfigs, String configAbsPath)
-      throws ConfigurationException {
-
-    if (toolConfigs == null || toolConfigs.isEmpty()) {
-      return ImmutableList.of();
-    }
-
-    ImmutableList.Builder<BaseTool> resolvedTools = ImmutableList.builder();
-
-    for (ToolConfig toolConfig : toolConfigs) {
-      try {
-        if (isNullOrEmpty(toolConfig.name())) {
-          throw new ConfigurationException("Tool name cannot be empty");
-        }
-
-        String toolName = toolConfig.name().trim();
-
-        // Option 1: Try to resolve as a tool instance
-        BaseTool tool = resolveToolInstance(toolName);
-        if (tool != null) {
-          resolvedTools.add(tool);
-          logger.debug("Successfully resolved tool instance: {}", toolName);
-          continue;
-        }
-
-        // Option 2: Try to resolve as a tool class (with or without args)
-        BaseTool toolFromClass = resolveToolFromClass(toolName, toolConfig.args());
-        if (toolFromClass != null) {
-          resolvedTools.add(toolFromClass);
-          logger.debug("Successfully resolved tool from class: {}", toolName);
-          continue;
-        }
-
-        throw new ConfigurationException("Tool not found: " + toolName);
-
-      } catch (Exception e) {
-        String errorMsg = "Failed to resolve tool: " + toolConfig.name();
-        logger.error(errorMsg, e);
-        throw new ConfigurationException(errorMsg, e);
-      }
-    }
-
-    return resolvedTools.build();
-  }
-
-  /**
-   * Resolves a tool instance by its unique name or its static field reference.
-   *
-   * <p>It first checks the {@link ComponentRegistry} for a registered tool instance. If not found,
-   * and the name looks like a fully qualified Java name referencing a static field (e.g.,
-   * "com.google.mytools.MyToolClass.INSTANCE"), it attempts to resolve it via reflection using
-   * {@link #resolveInstanceViaReflection(String)}.
-   *
-   * @param toolName The name of the tool or a static field reference (e.g., "myTool",
-   *     "com.google.mytools.MyToolClass.INSTANCE").
-   * @return The resolved tool instance, or {@code null} if the tool is not found in the registry
-   *     and cannot be resolved via reflection.
-   */
-  @Nullable
-  static BaseTool resolveToolInstance(String toolName) {
-    ComponentRegistry registry = ComponentRegistry.getInstance();
-
-    // First try registry
-    Optional<BaseTool> toolOpt = ComponentRegistry.resolveToolInstance(toolName);
-    if (toolOpt.isPresent()) {
-      return toolOpt.get();
-    }
-
-    // If not in registry and looks like Java qualified name, try reflection
-    if (isJavaQualifiedName(toolName)) {
-      try {
-        BaseTool tool = resolveInstanceViaReflection(toolName);
-        if (tool != null) {
-          registry.register(toolName, tool);
-          logger.debug("Resolved and registered tool instance via reflection: {}", toolName);
-          return tool;
-        }
-      } catch (Exception e) {
-        logger.debug("Failed to resolve instance via reflection: {}", toolName, e);
-      }
-    }
-    logger.debug("Could not resolve tool instance: {}", toolName);
-    return null;
-  }
-
-  /**
-   * Resolves a tool from a class name and optional arguments.
-   *
-   * <p>It attempts to load the class specified by {@code className}. If {@code args} are provided
-   * and non-empty, it looks for a static factory method {@code fromConfig(ToolArgsConfig)} on the
-   * class to instantiate the tool. If {@code args} are null or empty, it looks for a default
-   * constructor.
-   *
-   * @param className The fully qualified name of the tool class to instantiate.
-   * @param args Optional configuration arguments for tool creation. If provided, the class must
-   *     implement a static {@code fromConfig(ToolArgsConfig)} factory method. If null or empty, the
-   *     class must have a default constructor.
-   * @return The instantiated tool instance, or {@code null} if the class cannot be found or loaded.
-   * @throws ConfigurationException if {@code args} are provided but no {@code fromConfig} method
-   *     exists, if {@code args} are not provided but no default constructor exists, or if
-   *     instantiation via the factory method or constructor fails.
-   */
-  @Nullable
-  static BaseTool resolveToolFromClass(String className, ToolArgsConfig args)
-      throws ConfigurationException {
-    ComponentRegistry registry = ComponentRegistry.getInstance();
-
-    // First try registry for class
-    Optional<Class<? extends BaseTool>> classOpt = ComponentRegistry.resolveToolClass(className);
-    Class<? extends BaseTool> toolClass = null;
-
-    if (classOpt.isPresent()) {
-      toolClass = classOpt.get();
-    } else if (isJavaQualifiedName(className)) {
-      // Try reflection to get class
-      try {
-        Class<?> clazz = Thread.currentThread().getContextClassLoader().loadClass(className);
-        if (BaseTool.class.isAssignableFrom(clazz)) {
-          toolClass = clazz.asSubclass(BaseTool.class);
-          // Optimization: register for reuse
-          registry.register(className, toolClass);
-          logger.debug("Resolved and registered tool class via reflection: {}", className);
-        }
-      } catch (ClassNotFoundException e) {
-        logger.debug("Failed to resolve class via reflection: {}", className, e);
-        return null;
-      }
-    }
-
-    if (toolClass == null) {
-      return null;
-    }
-
-    // If args provided and not empty, try fromConfig method first
-    if (args != null && !args.isEmpty()) {
-      try {
-        Method fromConfigMethod = toolClass.getMethod("fromConfig", ToolArgsConfig.class);
-        Object instance = fromConfigMethod.invoke(null, args);
-        if (instance instanceof BaseTool baseTool) {
-          return baseTool;
-        }
-      } catch (NoSuchMethodException e) {
-        throw new ConfigurationException(
-            "Class " + className + " does not have fromConfig method but args were provided.", e);
-      } catch (Exception e) {
-        logger.error("Error calling fromConfig on class {}", className, e);
-        throw new ConfigurationException("Error creating tool from class " + className, e);
-      }
-    }
-
-    // No args provided or empty args, try default constructor
-    try {
-      Constructor<? extends BaseTool> constructor = toolClass.getDeclaredConstructor();
-      constructor.setAccessible(true);
-      return constructor.newInstance();
-    } catch (NoSuchMethodException e) {
-      throw new ConfigurationException(
-          "Class " + className + " does not have a default constructor and no args were provided.",
-          e);
-    } catch (Exception e) {
-      logger.error("Error calling default constructor on class {}", className, e);
-      throw new ConfigurationException(
-          "Error creating tool from class " + className + " using default constructor", e);
-    }
-  }
-
-  /**
-   * Checks if a string appears to be a Java fully qualified name, such as "com.google.adk.MyClass"
-   * or "com.google.adk.MyClass.MY_FIELD".
-   *
-   * <p>It verifies that the name contains at least one dot ('.') and consists of characters valid
-   * for Java identifiers and package names.
-   *
-   * @param name The string to check.
-   * @return {@code true} if the string matches the pattern of a Java qualified name, {@code false}
-   *     otherwise.
-   */
-  static boolean isJavaQualifiedName(String name) {
-    if (name == null || name.trim().isEmpty()) {
-      return false;
-    }
-    return name.contains(".") && name.matches("^[a-zA-Z_$][a-zA-Z0-9_.$]*$");
-  }
-
-  /**
-   * Resolves a {@link BaseTool} instance by attempting to access a public static field via
-   * reflection.
-   *
-   * <p>This method expects {@code toolName} to be in the format
-   * "com.google.package.ClassName.STATIC_FIELD_NAME", where "STATIC_FIELD_NAME" is the name of a
-   * public static field in "com.google.package.ClassName" that holds a {@link BaseTool} instance.
-   *
-   * @param toolName The fully qualified name of a static field holding a tool instance.
-   * @return The {@link BaseTool} instance, or {@code null} if {@code toolName} is not in the
-   *     expected format, or if the field is not found, not static, or not of type {@link BaseTool}.
-   * @throws Exception if the class specified in {@code toolName} cannot be loaded, or if there is a
-   *     security manager preventing reflection, or if accessing the field causes an exception.
-   */
-  @Nullable
-  static BaseTool resolveInstanceViaReflection(String toolName) throws Exception {
-    int lastDotIndex = toolName.lastIndexOf('.');
-    if (lastDotIndex == -1) {
-      return null;
-    }
-
-    String className = toolName.substring(0, lastDotIndex);
-    String fieldName = toolName.substring(lastDotIndex + 1);
-
-    Class<?> clazz = Thread.currentThread().getContextClassLoader().loadClass(className);
-
-    try {
-      Field field = clazz.getField(fieldName);
-      if (!Modifier.isStatic(field.getModifiers())) {
-        logger.debug("Field {} in class {} is not static", fieldName, className);
-        return null;
-      }
-      Object instance = field.get(null);
-      if (instance instanceof BaseTool baseTool) {
-        return baseTool;
-      } else {
-        logger.debug("Field {} in class {} is not a BaseTool instance", fieldName, className);
-      }
-    } catch (NoSuchFieldException e) {
-      logger.debug("Field {} not found in class {}", fieldName, className);
-    }
-    return null;
-  }
 }