feat: add ParallelAgent.fromConfig()

PiperOrigin-RevId: 834310422

Author: google-genai-bot

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

@@ -220,6 +220,10 @@ private static Class<? extends BaseAgentConfig> getConfigClassForAgent(
       return SequentialAgentConfig.class;
     }
 
+    if (agentClass == ParallelAgent.class) {
+      return ParallelAgentConfig.class;
+    }
+
     // TODO: Add more agent class to config class mappings as needed
     // Example:
     // if (agentClass == CustomAgent.class) {

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

@@ -17,13 +17,20 @@
 package com.google.adk.agents;
 
 import static com.google.common.base.Strings.isNullOrEmpty;
+import static com.google.common.base.Strings.nullToEmpty;
 
+import com.google.adk.agents.ConfigAgentUtils.ConfigurationException;
 import com.google.adk.events.Event;
+import com.google.adk.utils.ComponentRegistry;
 import com.google.common.collect.ImmutableList;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import io.reactivex.rxjava3.core.Flowable;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.Consumer;
+import javax.annotation.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
  * A shell agent that runs its sub-agents in parallel in isolated manner.
@@ -34,6 +41,8 @@
  */
 public class ParallelAgent extends BaseAgent {
 
+  private static final Logger logger = LoggerFactory.getLogger(ParallelAgent.class);
+
   /**
    * Constructor for ParallelAgent.
    *
@@ -120,6 +129,82 @@ public static Builder builder() {
     return new Builder();
   }
 
+  /**
+   * Creates a ParallelAgent from configuration.
+   *
+   * @param config the agent configuration
+   * @param configAbsPath The absolute path to the agent config file.
+   * @return the configured ParallelAgent
+   * @throws ConfigurationException if the configuration is invalid
+   */
+  public static ParallelAgent fromConfig(ParallelAgentConfig config, String configAbsPath)
+      throws ConfigurationException {
+    logger.debug("Creating ParallelAgent from config: {}", config.name());
+
+    // Validate required fields
+    if (config.name() == null || config.name().trim().isEmpty()) {
+      throw new ConfigurationException("Agent name is required");
+    }
+
+    // Create builder with required fields
+    Builder builder =
+        ParallelAgent.builder().name(config.name()).description(nullToEmpty(config.description()));
+
+    // Resolve and add subagents using the utility class
+    if (config.subAgents() != null && !config.subAgents().isEmpty()) {
+      ImmutableList<BaseAgent> subAgents =
+          ConfigAgentUtils.resolveSubAgents(config.subAgents(), configAbsPath);
+      builder.subAgents(subAgents);
+    }
+
+    // Resolve callbacks if configured
+    setCallbacksFromConfig(config, builder);
+
+    // Build and return the agent
+    ParallelAgent agent = builder.build();
+    logger.info(
+        "Successfully created ParallelAgent: {} with {} subagents",
+        agent.name(),
+        agent.subAgents() != null ? agent.subAgents().size() : 0);
+
+    return agent;
+  }
+
+  private static void setCallbacksFromConfig(ParallelAgentConfig config, Builder builder)
+      throws ConfigurationException {
+    setCallbackFromConfig(
+        config.beforeAgentCallbacks(),
+        Callbacks.BeforeAgentCallbackBase.class,
+        "before_agent_callback",
+        builder::beforeAgentCallback);
+    setCallbackFromConfig(
+        config.afterAgentCallbacks(),
+        Callbacks.AfterAgentCallbackBase.class,
+        "after_agent_callback",
+        builder::afterAgentCallback);
+  }
+
+  private static <T> void setCallbackFromConfig(
+      @Nullable List<ParallelAgentConfig.CallbackRef> refs,
+      Class<T> callbackBaseClass,
+      String callbackTypeName,
+      Consumer<ImmutableList<T>> builderSetter)
+      throws ConfigurationException {
+    if (refs != null) {
+      ImmutableList.Builder<T> list = ImmutableList.builder();
+      for (ParallelAgentConfig.CallbackRef ref : refs) {
+        list.add(
+            ComponentRegistry.getInstance()
+                .get(ref.name(), callbackBaseClass)
+                .orElseThrow(
+                    () ->
+                        new ConfigurationException(
+                            "Invalid " + callbackTypeName + ": " + ref.name())));
+      }
+      builderSetter.accept(list.build());
+    }
+  }
+
   /**
    * Sets the branch for the current agent in the invocation context.
    *

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

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2025 Google LLC
+ *
+ * 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 com.google.adk.agents;
+
+import java.util.List;
+
+/** Configuration for ParallelAgent. */
+public class ParallelAgentConfig extends BaseAgentConfig {
+
+  // Callback configuration (names resolved via ComponentRegistry)
+  private List<CallbackRef> beforeAgentCallbacks;
+  private List<CallbackRef> afterAgentCallbacks;
+
+  /** Reference to a callback stored in the ComponentRegistry. */
+  public static class CallbackRef {
+    private String name;
+
+    public CallbackRef() {}
+
+    public CallbackRef(String name) {
+      this.name = name;
+    }
+
+    public String name() {
+      return name;
+    }
+
+    public void setName(String name) {
+      this.name = name;
+    }
+  }
+
+  public ParallelAgentConfig() {
+    super();
+    setAgentClass("ParallelAgent");
+  }
+
+  public List<CallbackRef> beforeAgentCallbacks() {
+    return beforeAgentCallbacks;
+  }
+
+  public void setBeforeAgentCallbacks(List<CallbackRef> beforeAgentCallbacks) {
+    this.beforeAgentCallbacks = beforeAgentCallbacks;
+  }
+
+  public List<CallbackRef> afterAgentCallbacks() {
+    return afterAgentCallbacks;
+  }
+
+  public void setAfterAgentCallbacks(List<CallbackRef> afterAgentCallbacks) {
+    this.afterAgentCallbacks = afterAgentCallbacks;
+  }
+}