Introduce LangChain4j Agentic Workflow Implementation

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

Author: ricardozanini

fluent/agentic-langchain4j/pom.xml

@@ -0,0 +1,68 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>io.serverlessworkflow</groupId>
+        <artifactId>serverlessworkflow-fluent</artifactId>
+        <version>8.0.0-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>serverlessworkflow-fluent-agentic-langchain4j</artifactId>
+    <name>Serverless Workflow :: Fluent :: Agentic LangChain4j</name>
+    <description>Agentic Workflow DSL Implementation for langchain4j-agentic</description>
+
+    <dependencies>
+        <dependency>
+            <groupId>io.serverlessworkflow</groupId>
+            <artifactId>serverlessworkflow-experimental-types</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.serverlessworkflow</groupId>
+            <artifactId>serverlessworkflow-fluent-agentic</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>dev.langchain4j</groupId>
+            <artifactId>langchain4j-agentic</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-simple</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>dev.langchain4j</groupId>
+            <artifactId>langchain4j-ollama</artifactId>
+            <scope>test</scope>
+            <version>${version.dev.langchain4j}</version>
+        </dependency>
+        <dependency>
+            <groupId>io.serverlessworkflow</groupId>
+            <artifactId>serverlessworkflow-fluent-agentic</artifactId>
+            <type>test-jar</type>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+
+
+
+
+</project>

fluent/agentic-langchain4j/src/main/java/io/serverlessworkflow/fluent/agentic/langchain4j/AbstractAgentService.java

@@ -0,0 +1,70 @@
+/*
+ * 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.langchain4j;
+
+import dev.langchain4j.agentic.cognisphere.Cognisphere;
+import io.serverlessworkflow.api.types.Workflow;
+import io.serverlessworkflow.fluent.agentic.AgentWorkflowBuilder;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+public abstract class AbstractAgentService<T, S> implements WorkflowDefinitionBuilder {
+
+  private static final Function<Cognisphere, Object> DEFAULT_OUTPUT_FUNCTION = cognisphere -> null;
+  private static final Consumer<Cognisphere> DEFAULT_INIT_FUNCTION = cognisphere -> {};
+
+  protected final AgentWorkflowBuilder workflowBuilder;
+  protected final Class<T> agentServiceClass;
+
+  protected AbstractAgentService(Class<T> agentServiceClass) {
+    this("", agentServiceClass);
+  }
+
+  protected AbstractAgentService(String name, Class<T> agentServiceClass) {
+    this.workflowBuilder =
+        AgentWorkflowBuilder.workflow(name)
+            .outputAs(DEFAULT_OUTPUT_FUNCTION)
+            .input(i -> i.from(DEFAULT_INIT_FUNCTION));
+    this.agentServiceClass = agentServiceClass;
+  }
+
+  @SuppressWarnings("unchecked")
+  public S beforeCall(Consumer<Cognisphere> beforeCall) {
+    // TODO: Our runner must know that our input can be a cognisphere object and extract it from the
+    // context, so that we can accept the consumer.
+    // TODO: For now, we can add the consumer to inputFrom
+    this.workflowBuilder.input(i -> i.from(beforeCall));
+    return (S) this;
+  }
+
+  @SuppressWarnings("unchecked")
+  public S outputName(String outputName) {
+    // TODO: This can be solved using a combination with our output object
+    this.workflowBuilder.document(d -> d.name(outputName));
+    return (S) this;
+  }
+
+  @SuppressWarnings("unchecked")
+  public S output(Function<Cognisphere, Object> output) {
+    this.workflowBuilder.outputAs(output);
+    return (S) this;
+  }
+
+  @Override
+  public Workflow getDefinition() {
+    return this.workflowBuilder.build();
+  }
+}

fluent/agentic-langchain4j/src/main/java/io/serverlessworkflow/fluent/agentic/langchain4j/ConditionalAgentServiceImpl.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.langchain4j;
+
+import dev.langchain4j.agentic.cognisphere.Cognisphere;
+import dev.langchain4j.agentic.internal.AgentExecutor;
+import dev.langchain4j.agentic.workflow.ConditionalAgentService;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Predicate;
+
+public class ConditionalAgentServiceImpl<T>
+    extends AbstractAgentService<T, ConditionalAgentService<T>>
+    implements ConditionalAgentService<T> {
+
+  private ConditionalAgentServiceImpl(Class<T> agentServiceClass) {
+    super(agentServiceClass);
+  }
+
+  public static <T> ConditionalAgentService<T> builder(Class<T> agentServiceClass) {
+    return new ConditionalAgentServiceImpl<>(agentServiceClass);
+  }
+
+  @Override
+  public T build() {
+    return null;
+  }
+
+  @Override
+  public ConditionalAgentService<T> subAgents(Object... agents) {
+    this.workflowBuilder.tasks(t -> t.sequence(agents));
+    return this;
+  }
+
+  @Override
+  public ConditionalAgentService<T> subAgents(List<AgentExecutor> agentExecutors) {
+    return this.subAgents(agentExecutors.toArray());
+  }
+
+  @Override
+  public ConditionalAgentService<T> subAgents(Predicate<Cognisphere> condition, Object... agents) {
+    this.workflowBuilder.tasks(
+        t -> Arrays.stream(agents).forEach(agent -> t.when(condition).agent(agent)));
+    return this;
+  }
+
+  @Override
+  public ConditionalAgentService<T> subAgents(
+      Predicate<Cognisphere> condition, List<AgentExecutor> agentExecutors) {
+    return this.subAgents(condition, agentExecutors.toArray());
+  }
+
+  @Override
+  public ConditionalAgentService<T> subAgent(
+      Predicate<Cognisphere> condition, AgentExecutor agentExecutor) {
+    this.workflowBuilder.tasks(t -> t.when(condition).agent(agentExecutor));
+    return this;
+  }
+}

fluent/agentic-langchain4j/src/main/java/io/serverlessworkflow/fluent/agentic/langchain4j/LC4JWorkflowBuilder.java

@@ -0,0 +1,66 @@
+/*
+ * 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.langchain4j;
+
+import dev.langchain4j.agentic.UntypedAgent;
+import dev.langchain4j.agentic.workflow.ConditionalAgentService;
+import dev.langchain4j.agentic.workflow.LoopAgentService;
+import dev.langchain4j.agentic.workflow.ParallelAgentService;
+import dev.langchain4j.agentic.workflow.SequentialAgentService;
+import dev.langchain4j.agentic.workflow.WorkflowAgentsBuilder;
+
+public class LC4JWorkflowBuilder implements WorkflowAgentsBuilder {
+
+  @Override
+  public SequentialAgentService<UntypedAgent> sequenceBuilder() {
+    return SequentialAgentServiceImpl.builder(UntypedAgent.class);
+  }
+
+  @Override
+  public <T> SequentialAgentService<T> sequenceBuilder(Class<T> agentServiceClass) {
+    return SequentialAgentServiceImpl.builder(agentServiceClass);
+  }
+
+  @Override
+  public ParallelAgentService<UntypedAgent> parallelBuilder() {
+    return ParallelAgentServiceImpl.builder(UntypedAgent.class);
+  }
+
+  @Override
+  public <T> ParallelAgentService<T> parallelBuilder(Class<T> agentServiceClass) {
+    return ParallelAgentServiceImpl.builder(agentServiceClass);
+  }
+
+  @Override
+  public LoopAgentService<UntypedAgent> loopBuilder() {
+    return LoopAgentServiceImpl.builder(UntypedAgent.class);
+  }
+
+  @Override
+  public <T> LoopAgentService<T> loopBuilder(Class<T> agentServiceClass) {
+    return LoopAgentServiceImpl.builder(agentServiceClass);
+  }
+
+  @Override
+  public ConditionalAgentService<UntypedAgent> conditionalBuilder() {
+    return ConditionalAgentServiceImpl.builder(UntypedAgent.class);
+  }
+
+  @Override
+  public <T> ConditionalAgentService<T> conditionalBuilder(Class<T> agentServiceClass) {
+    return ConditionalAgentServiceImpl.builder(agentServiceClass);
+  }
+}

fluent/agentic-langchain4j/src/main/java/io/serverlessworkflow/fluent/agentic/langchain4j/LoopAgentServiceImpl.java

@@ -0,0 +1,68 @@
+/*
+ * 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.langchain4j;
+
+import dev.langchain4j.agentic.cognisphere.Cognisphere;
+import dev.langchain4j.agentic.internal.AgentExecutor;
+import dev.langchain4j.agentic.workflow.LoopAgentService;
+import io.serverlessworkflow.fluent.agentic.LoopAgentsBuilder;
+import java.util.List;
+import java.util.function.Predicate;
+
+public class LoopAgentServiceImpl<T> extends AbstractAgentService<T, LoopAgentService<T>>
+    implements LoopAgentService<T> {
+
+  private final LoopAgentsBuilder loopAgentsBuilder = new LoopAgentsBuilder();
+
+  private LoopAgentServiceImpl(Class<T> agentServiceClass) {
+    super(agentServiceClass);
+  }
+
+  public static <T> LoopAgentService<T> builder(Class<T> agentServiceClass) {
+    return new LoopAgentServiceImpl<>(agentServiceClass);
+  }
+
+  @Override
+  public LoopAgentService<T> maxIterations(int maxIterations) {
+    this.loopAgentsBuilder.maxIterations(maxIterations);
+    return this;
+  }
+
+  @Override
+  public LoopAgentService<T> exitCondition(Predicate<Cognisphere> exitCondition) {
+    this.loopAgentsBuilder.exitCondition(exitCondition);
+    return this;
+  }
+
+  @Override
+  public T build() {
+    return null;
+  }
+
+  @Override
+  public LoopAgentService<T> subAgents(Object... agents) {
+    this.loopAgentsBuilder.subAgents(agents);
+    this.workflowBuilder.tasks(t -> t.loop(this.loopAgentsBuilder));
+    return this;
+  }
+
+  @Override
+  public LoopAgentService<T> subAgents(List<AgentExecutor> agentExecutors) {
+    this.loopAgentsBuilder.subAgents(agentExecutors.toArray());
+    this.workflowBuilder.tasks(t -> t.loop(this.loopAgentsBuilder));
+    return this;
+  }
+}