@@ -0,0 +1,108 @@
+package datadog.trace.agent.tooling;
+
+import static datadog.trace.agent.tooling.HelperScanner.isHelperClass;
+import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named;
+import static net.bytebuddy.matcher.ElementMatchers.returns;
+import static net.bytebuddy.matcher.ElementMatchers.takesArguments;
+
+import datadog.trace.agent.tooling.advice.AdviceScanResult;
+import datadog.trace.agent.tooling.advice.AdviceScanResult.ClassInfo;
+import datadog.trace.agent.tooling.advice.AdviceScanResult.Usage;
+import datadog.trace.agent.tooling.muzzle.Reference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.dynamic.DynamicType;
+import net.bytebuddy.implementation.Implementation;
+import net.bytebuddy.implementation.bytecode.StackManipulation;
+import net.bytebuddy.implementation.bytecode.collection.ArrayFactory;
+import net.bytebuddy.implementation.bytecode.constant.TextConstant;
+import net.bytebuddy.implementation.bytecode.member.MethodReturn;
+
+/** Resolves injectable helpers and generates {@code helperClassNames()} when none are declared. */
+public final class HelperGenerationProcessor {
+  private static final String MUZZLE_REFERENCE_PREFIX = Reference.class.getName();
+
+  public String[] resolveHelpers(AdviceScanResult scanResult, InstrumenterModule module) {
+    String[] declaredHelpers = module.helperClassNames();
+    if (declaredHelpers.length > 0) {
+      return declaredHelpers;
+    }
+
+    Set<String> adviceRoots = new HashSet<>(scanResult.getAdviceRoots());
+    Set<String> helpers = new LinkedHashSet<>();
+    for (ClassInfo info : scanResult.getClasses().values()) {
+      if (info.isScanned()
+          && info.isReachableFromAdvice()
+          && !adviceRoots.contains(info.getClassName())
+          && isHelperClass(info.getClassName(), info.isFromModuleOutput())
+          && !isBuildTimeOnly(info)) {
+        helpers.add(info.getClassName());
+      }
+    }
+
+    List<String> ordered = new ArrayList<>(helpers.size());
+    Set<String> visited = new HashSet<>();
+    for (String helper : helpers) {
+      addInDependencyOrder(helper, helpers, scanResult, visited, ordered);
+    }
+    return ordered.toArray(new String[0]);
+  }
+
+  public DynamicType.Builder<?> transform(
+      DynamicType.Builder<?> builder, String[] helpers, InstrumenterModule module) {
+    if (helpers.length == 0 || module.helperClassNames().length > 0) {
+      return builder;
+    }
+    List<StackManipulation> values = new ArrayList<>(helpers.length);
+    for (String helper : helpers) {
+      values.add(new TextConstant(helper));
+    }
+    return builder
+        .method(named("helperClassNames").and(takesArguments(0)).and(returns(String[].class)))
+        .intercept(
+            new Implementation.Simple(
+                ArrayFactory.forType(
+                        new TypeDescription.ForLoadedType(String.class).asGenericType())
+                    .withValues(values),
+                MethodReturn.REFERENCE));
+  }
+
+  private static boolean isBuildTimeOnly(ClassInfo info) {
+    for (String dependency : info.getRequiredDependencies()) {
+      if (dependency.startsWith(MUZZLE_REFERENCE_PREFIX)) {
+        return true;
+      }
+    }
+    // Some muzzle helpers only construct references inside methods, without implementing a
+    // provider.
+    for (Usage usage : info.getUsages()) {
+      String owner = usage.getOwner();
+      if (owner != null && owner.startsWith(MUZZLE_REFERENCE_PREFIX)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private static void addInDependencyOrder(
+      String className,
+      Set<String> helpers,
+      AdviceScanResult scanResult,
+      Set<String> visited,
+      List<String> ordered) {
+    if (!visited.add(className)) {
+      return;
+    }
+    ClassInfo info = scanResult.getClassInfo(className);
+    for (String dependency : info.getRequiredDependencies()) {
+      if (helpers.contains(dependency)) {
+        addInDependencyOrder(dependency, helpers, scanResult, visited, ordered);
+      }
+    }
+    ordered.add(className);
+  }
+}
@@ -24,6 +24,12 @@
 public final class HelperScanner extends ClassVisitor {
   static final int READER_OPTIONS = ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES;
 
+  private static final String[] SHARED_HELPER_PREFIXES = {
+    "datadog.opentelemetry.shim.",
+    "datadog.trace.agent.tooling.iast.",
+    "datadog.trace.agent.tooling.nativeimage."
+  };
+
   static final ClassFileLocator locator =
       ClassFileLocator.ForClassLoader.of(Utils.getAgentClassLoader());
 
@@ -49,6 +55,22 @@ public static String[] withClassDependencies(String... helperClassNames) {
     return new HelperScanner().simulateClassLoading(helperClassNames);
   }
 
+  /** Whether a class can be injected as an instrumentation helper. */
+  public static boolean isHelperClass(String className, boolean fromModuleOutput) {
+    if (isBootstrapClass(className)) {
+      return false;
+    }
+    if (fromModuleOutput) {
+      return true;
+    }
+    for (String prefix : SHARED_HELPER_PREFIXES) {
+      if (className.startsWith(prefix)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   /**
    * Simulates class-loading by finding all classes required to load the helper classes as well as
    * optional classes used in method instructions that may be needed later when invoking the method.
@@ -256,26 +278,32 @@ void record(Type type, Consumer<String> action) {
       } else if (type.getSort() == Type.OBJECT) {
         String className = type.getClassName();
         // ignore types that we expect to be on the boot-class-path
-        if (this.className.equals(className)
-            || className.startsWith("java.")
-            || className.startsWith("javax.")
-            || className.startsWith("jdk.")
-            || className.startsWith("com.sun.")
-            || className.startsWith("sun.")
-            || className.startsWith("org.slf4j.")
-            || className.startsWith("datadog.slf4j.")) {
+        if (this.className.equals(className) || isBootstrapClass(className)) {
           return;
         }
-        for (String prefix : Constants.BOOTSTRAP_PACKAGE_PREFIXES) {
-          if (className.startsWith(prefix)) {
-            return;
-          }
-        }
         action.accept(className);
       }
     }
   }
 
+  private static boolean isBootstrapClass(String className) {
+    if (className.startsWith("java.")
+        || className.startsWith("javax.")
+        || className.startsWith("jdk.")
+        || className.startsWith("com.sun.")
+        || className.startsWith("sun.")
+        || className.startsWith("org.slf4j.")
+        || className.startsWith("datadog.slf4j.")) {
+      return true;
+    }
+    for (String prefix : Constants.BOOTSTRAP_PACKAGE_PREFIXES) {
+      if (className.startsWith(prefix)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   void record(Type[] types, Consumer<String> action) {
     if (null != types) {
       for (Type t : types) {
 
@@ -113,7 +113,11 @@ public static ReferenceMatcher loadStaticMuzzleReferences(
   }
 
   /**
-   * @return Class names of helpers to inject into the user's classloader.
+   * @return Class names of helpers to inject into the user's classloader. A non-empty list is used
+   *     exactly as declared; an empty list means helpers will be inferred from method advice at
+   *     build-time by following bytecode references. Helpers loaded only through reflection or
+   *     class name strings may not be discovered. Modules needing these undiscoverable helpers must
+   *     declare the complete helper list - declared and inferred helpers are not merged.
    *     <p><b>NOTE:</b> The order of the returned helper classes matters. If a muzzle check fails
    *     with a NoClassDefFoundError, as logged in build/reports/muzzle-*.txt, it is likely that one
    *     helper class depends on another that appears later in the list. In this case, the returned
 
@@ -3,14 +3,17 @@
 import datadog.trace.agent.tooling.InstrumenterModule;
 import java.io.File;
 
-/** Module and output directory shared by advice processors. */
+/** Module, output directory, and resolved helpers shared by advice processors. */
 public final class AdviceProcessorContext {
   private final InstrumenterModule module;
   private final File targetDirectory;
+  private final String[] helperClassNames;
 
-  AdviceProcessorContext(InstrumenterModule module, File targetDirectory) {
+  AdviceProcessorContext(
+      InstrumenterModule module, File targetDirectory, String[] helperClassNames) {
     this.module = module;
     this.targetDirectory = targetDirectory;
+    this.helperClassNames = helperClassNames;
   }
 
   public InstrumenterModule getModule() {
@@ -20,4 +23,8 @@ public InstrumenterModule getModule() {
   public File getTargetDirectory() {
     return targetDirectory;
   }
+
+  public String[] getHelperClassNames() {
+    return helperClassNames;
+  }
 }
@@ -156,12 +156,24 @@ public List<HandleUse> getHandles() {
   /** One discovered class. External leaves have no scanned bytecode. */
   public static final class ClassInfo {
     private final String className;
+    private final boolean fromModuleOutput;
     private final boolean scanned;
+    private final boolean reachableFromAdvice;
+    private final List<String> requiredDependencies;
     private final List<Usage> usages;
 
-    ClassInfo(String className, boolean scanned, List<Usage> usages) {
+    ClassInfo(
+        String className,
+        boolean fromModuleOutput,
+        boolean scanned,
+        boolean reachableFromAdvice,
+        Collection<String> requiredDependencies,
+        List<Usage> usages) {
       this.className = className;
+      this.fromModuleOutput = fromModuleOutput;
       this.scanned = scanned;
+      this.reachableFromAdvice = reachableFromAdvice;
+      this.requiredDependencies = immutableCopy(requiredDependencies);
       this.usages = immutableCopy(usages);
     }
 
@@ -173,13 +185,28 @@ public boolean isScanned() {
       return scanned;
     }
 
+    public boolean isFromModuleOutput() {
+      return fromModuleOutput;
+    }
+
+    /**
+     * Whether an advice root reaches this class through dependencies (i.e. not nested enumeration).
+     */
+    public boolean isReachableFromAdvice() {
+      return reachableFromAdvice;
+    }
+
     public boolean isInstrumentationClass() {
       return AdviceScanResult.isInstrumentationClass(className);
     }
 
     public List<Usage> getUsages() {
       return usages;
     }
+
+    public List<String> getRequiredDependencies() {
+      return requiredDependencies;
+    }
   }
 
   private final List<String> adviceRoots;