Fix #732 - Add static imports and consumer recipes for Agentic DSL (#785)

* Fix #732 - Add static imports and consumer recipes for Agentic DSL

Signed-off-by: Ricardo Zanini <ricardozanini@gmail.com>

* Adding agentic workflow patterns to the DSL

Signed-off-by: Ricardo Zanini <ricardozanini@gmail.com>

---------

Signed-off-by: Ricardo Zanini <ricardozanini@gmail.com>

Author: ricardozanini

experimental/fluent/agentic/src/main/java/io/serverlessworkflow/fluent/agentic/AgentWorkflowBuilder.java

@@ -15,9 +15,11 @@
  */
 package io.serverlessworkflow.fluent.agentic;
 
+import dev.langchain4j.agentic.scope.AgenticScope;
 import io.serverlessworkflow.fluent.func.spi.FuncTransformations;
 import io.serverlessworkflow.fluent.spec.BaseWorkflowBuilder;
 import java.util.UUID;
+import java.util.function.Predicate;
 
 public class AgentWorkflowBuilder
     extends BaseWorkflowBuilder<AgentWorkflowBuilder, AgentDoTaskBuilder, AgentTaskItemListBuilder>
@@ -40,6 +42,40 @@ public static AgentWorkflowBuilder workflow(String name, String ns) {
     return new AgentWorkflowBuilder(name, ns, DEFAULT_VERSION);
   }
 
+  public AgentWorkflowBuilder sequence(Object... agents) {
+    return sequence(UUID.randomUUID().toString(), agents);
+  }
+
+  public AgentWorkflowBuilder sequence(String name, Object... agents) {
+    final AgentDoTaskBuilder doTaskBuilder = this.newDo();
+    doTaskBuilder.sequence(name, agents);
+    this.workflow.setDo(doTaskBuilder.build().getDo());
+    return this;
+  }
+
+  public AgentWorkflowBuilder parallel(Object... agents) {
+    return this.parallel(UUID.randomUUID().toString(), agents);
+  }
+
+  public AgentWorkflowBuilder parallel(String name, Object... agents) {
+    final AgentDoTaskBuilder doTaskBuilder = this.newDo();
+    doTaskBuilder.parallel(name, agents);
+    this.workflow.setDo(doTaskBuilder.build().getDo());
+    return this;
+  }
+
+  public AgentWorkflowBuilder loop(Predicate<AgenticScope> exitCondition, Object... agents) {
+    return this.loop(UUID.randomUUID().toString(), exitCondition, agents);
+  }
+
+  public AgentWorkflowBuilder loop(
+      String name, Predicate<AgenticScope> exitCondition, Object... agents) {
+    final AgentDoTaskBuilder doTaskBuilder = this.newDo();
+    doTaskBuilder.loop(name, loop -> loop.subAgents(agents).exitCondition(exitCondition));
+    this.workflow.setDo(doTaskBuilder.build().getDo());
+    return this;
+  }
+
   @Override
   protected AgentDoTaskBuilder newDo() {
     return new AgentDoTaskBuilder();

experimental/fluent/agentic/src/main/java/io/serverlessworkflow/fluent/agentic/configurer/AgentTaskConfigurer.java

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2020-Present The Serverless Workflow Specification Authors
+ *
+ * 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.serverlessworkflow.fluent.agentic.configurer;
+
+import io.serverlessworkflow.fluent.agentic.AgentDoTaskBuilder;
+import java.util.function.Consumer;
+
+@FunctionalInterface
+public interface AgentTaskConfigurer extends Consumer<AgentDoTaskBuilder> {}

experimental/fluent/agentic/src/main/java/io/serverlessworkflow/fluent/agentic/configurer/FuncPredicateEventConfigurer.java

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2020-Present The Serverless Workflow Specification Authors
+ *
+ * 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.serverlessworkflow.fluent.agentic.configurer;
+
+import io.serverlessworkflow.fluent.func.FuncPredicateEventPropertiesBuilder;
+import java.util.function.Consumer;
+
+@FunctionalInterface
+public interface FuncPredicateEventConfigurer
+    extends Consumer<FuncPredicateEventPropertiesBuilder> {}

experimental/fluent/agentic/src/main/java/io/serverlessworkflow/fluent/agentic/configurer/ListenConfigurer.java

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2020-Present The Serverless Workflow Specification Authors
+ *
+ * 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.serverlessworkflow.fluent.agentic.configurer;
+
+import io.serverlessworkflow.fluent.agentic.AgentListenTaskBuilder;
+import java.util.function.Consumer;
+
+@FunctionalInterface
+public interface ListenConfigurer extends Consumer<AgentListenTaskBuilder> {}

experimental/fluent/agentic/src/main/java/io/serverlessworkflow/fluent/agentic/configurer/SwitchCaseConfigurer.java

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2020-Present The Serverless Workflow Specification Authors
+ *
+ * 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.serverlessworkflow.fluent.agentic.configurer;
+
+import io.serverlessworkflow.fluent.func.FuncSwitchTaskBuilder;
+import java.util.function.Consumer;
+
+@FunctionalInterface
+public interface SwitchCaseConfigurer
+    extends Consumer<FuncSwitchTaskBuilder.SwitchCasePredicateBuilder> {}

experimental/fluent/agentic/src/main/java/io/serverlessworkflow/fluent/agentic/dsl/AgenticDSL.java

@@ -0,0 +1,150 @@
+/*
+ * Copyright 2020-Present The Serverless Workflow Specification Authors
+ *
+ * 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.serverlessworkflow.fluent.agentic.dsl;
+
+import dev.langchain4j.agentic.scope.AgenticScope;
+import io.cloudevents.CloudEventData;
+import io.serverlessworkflow.api.types.FlowDirectiveEnum;
+import io.serverlessworkflow.fluent.agentic.AgentDoTaskBuilder;
+import io.serverlessworkflow.fluent.agentic.configurer.AgentTaskConfigurer;
+import io.serverlessworkflow.fluent.agentic.configurer.FuncPredicateEventConfigurer;
+import io.serverlessworkflow.fluent.agentic.configurer.SwitchCaseConfigurer;
+import io.serverlessworkflow.fluent.func.FuncCallTaskBuilder;
+import io.serverlessworkflow.fluent.func.FuncEmitTaskBuilder;
+import io.serverlessworkflow.fluent.func.FuncSwitchTaskBuilder;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+public final class AgenticDSL {
+
+  private AgenticDSL() {}
+
+  public static <T, V> Consumer<FuncCallTaskBuilder> fn(
+      Function<T, V> function, Class<T> argClass) {
+    return f -> f.function(function, argClass);
+  }
+
+  public static <T, V> Consumer<FuncCallTaskBuilder> fn(Function<T, V> function) {
+    return f -> f.function(function);
+  }
+
+  public static Consumer<FuncSwitchTaskBuilder> cases(SwitchCaseConfigurer... cases) {
+    return s -> {
+      for (SwitchCaseConfigurer c : cases) {
+        s.onPredicate(c);
+      }
+    };
+  }
+
+  public static <T> SwitchCaseSpec<T> on(Predicate<T> when, Class<T> whenClass) {
+    return new SwitchCaseSpec<T>().when(when, whenClass);
+  }
+
+  public static <T> SwitchCaseSpec<T> on(Predicate<T> when) {
+    return new SwitchCaseSpec<T>().when(when);
+  }
+
+  public static SwitchCaseConfigurer onDefault(String task) {
+    return s -> s.then(task);
+  }
+
+  public static SwitchCaseConfigurer onDefault(FlowDirectiveEnum directive) {
+    return s -> s.then(directive);
+  }
+
+  public static ListenSpec to() {
+    return new ListenSpec();
+  }
+
+  public static ListenSpec toOne(String type) {
+    return new ListenSpec().one(e -> e.type(type));
+  }
+
+  public static ListenSpec toAll(String... types) {
+    FuncPredicateEventConfigurer[] events = new FuncPredicateEventConfigurer[types.length];
+    for (int i = 0; i < types.length; i++) {
+      events[i] = event(types[i]);
+    }
+    return new ListenSpec().all(events);
+  }
+
+  public static ListenSpec toAny(String... types) {
+    FuncPredicateEventConfigurer[] events = new FuncPredicateEventConfigurer[types.length];
+    for (int i = 0; i < types.length; i++) {
+      events[i] = event(types[i]);
+    }
+    return new ListenSpec().any(events);
+  }
+
+  public static FuncPredicateEventConfigurer event(String type) {
+    return e -> e.type(type);
+  }
+
+  // TODO: expand the `event` static ref with more attributes based on community feedback
+
+  public static <T> Consumer<FuncEmitTaskBuilder> event(
+      String type, Function<T, CloudEventData> function) {
+    return event -> event.event(e -> e.type(type).data(function));
+  }
+
+  public static <T> Consumer<FuncEmitTaskBuilder> event(
+      String type, Function<T, CloudEventData> function, Class<T> clazz) {
+    return event -> event.event(e -> e.type(type).data(function, clazz));
+  }
+
+  // -------- Agentic Workflow Patterns -------- //
+  public static AgentTaskConfigurer sequence(Object... agents) {
+    return list -> list.sequence(agents);
+  }
+
+  public static AgentTaskConfigurer loop(Predicate<AgenticScope> exitCondition, Object... agents) {
+    return list -> list.loop(l -> l.subAgents(agents).exitCondition(exitCondition));
+  }
+
+  public static AgentTaskConfigurer parallel(Object... agents) {
+    return list -> list.parallel(agents);
+  }
+
+  // --------- Tasks ------ //
+  public static Consumer<AgentDoTaskBuilder> doTasks(AgentTaskConfigurer... steps) {
+    Objects.requireNonNull(steps, "Steps in a tasks are required");
+    final List<AgentTaskConfigurer> snapshot = List.of(steps.clone());
+    return list -> snapshot.forEach(s -> s.accept(list));
+  }
+
+  public static <T, V> AgentTaskConfigurer function(Function<T, V> function, Class<T> argClass) {
+    return list -> list.callFn(fn(function, argClass));
+  }
+
+  public static <T, V> AgentTaskConfigurer function(Function<T, V> function) {
+    return list -> list.callFn(fn(function));
+  }
+
+  public static AgentTaskConfigurer agent(Object agent) {
+    return list -> list.agent(agent);
+  }
+
+  public static AgentTaskConfigurer emit(Consumer<FuncEmitTaskBuilder> event) {
+    return list -> list.emit(event);
+  }
+
+  public static AgentTaskConfigurer switchCase(Consumer<FuncSwitchTaskBuilder> switchCase) {
+    return list -> list.switchCase(switchCase);
+  }
+}

experimental/fluent/agentic/src/main/java/io/serverlessworkflow/fluent/agentic/dsl/ListenSpec.java

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2020-Present The Serverless Workflow Specification Authors
+ *
+ * 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.serverlessworkflow.fluent.agentic.dsl;
+
+import io.serverlessworkflow.fluent.agentic.AgentListenTaskBuilder;
+import io.serverlessworkflow.fluent.agentic.configurer.FuncPredicateEventConfigurer;
+import io.serverlessworkflow.fluent.agentic.configurer.ListenConfigurer;
+import io.serverlessworkflow.fluent.func.FuncEventFilterBuilder;
+import io.serverlessworkflow.fluent.func.FuncListenToBuilder;
+import java.util.Objects;
+import java.util.function.Consumer;
+
+public class ListenSpec implements ListenConfigurer {
+
+  private Consumer<FuncListenToBuilder> strategyStep;
+  private Consumer<FuncListenToBuilder> untilStep;
+
+  @SuppressWarnings("unchecked")
+  private static Consumer<FuncEventFilterBuilder>[] asFilters(
+      FuncPredicateEventConfigurer[] events) {
+    Consumer<FuncEventFilterBuilder>[] filters = new Consumer[events.length];
+    for (int i = 0; i < events.length; i++) {
+      FuncPredicateEventConfigurer ev = Objects.requireNonNull(events[i], "events[" + i + "]");
+      filters[i] = f -> f.with(ev);
+    }
+    return filters;
+  }
+
+  public final ListenSpec all(FuncPredicateEventConfigurer... events) {
+    strategyStep = t -> t.all(asFilters(events));
+    return this;
+  }
+
+  public ListenSpec one(FuncPredicateEventConfigurer e) {
+    strategyStep = t -> t.one(f -> f.with(e));
+    return this;
+  }
+
+  public final ListenSpec any(FuncPredicateEventConfigurer... events) {
+    strategyStep = t -> t.any(asFilters(events));
+    return this;
+  }
+
+  public ListenSpec until(String expression) {
+    untilStep = t -> t.until(expression);
+    return this;
+  }
+
+  @Override
+  public void accept(AgentListenTaskBuilder agentListenTaskBuilder) {
+    agentListenTaskBuilder.to(
+        t -> {
+          strategyStep.accept(t);
+          if (untilStep != null) {
+            untilStep.accept(t);
+          }
+        });
+  }
+}