diff --git a/pom.xml b/pom.xml index 910570b36..b26acb29c 100644 --- a/pom.xml +++ b/pom.xml @@ -38,9 +38,9 @@ 3.12.1 3.7.0 3.4.2 - 11 - 11 - 11 + 17 + 17 + 17 true 2.16.2 true @@ -715,6 +715,7 @@ testcontainers-dapr durabletask-client + quarkus diff --git a/quarkus/README.md b/quarkus/README.md new file mode 100644 index 000000000..a6379ee17 --- /dev/null +++ b/quarkus/README.md @@ -0,0 +1,2 @@ +# quarkus-agentic-dapr +Quarkus Agentic Dapr Workflows integration diff --git a/quarkus/deployment/pom.xml b/quarkus/deployment/pom.xml new file mode 100644 index 000000000..bb75c756d --- /dev/null +++ b/quarkus/deployment/pom.xml @@ -0,0 +1,60 @@ + + + 4.0.0 + + io.dapr.quarkus + dapr-quarkus-agentic-parent + 1.18.0-SNAPSHOT + ../pom.xml + + + quarkus-agentic-dapr-deployment + Quarkus Agentic Dapr - Deployment + + + + io.quarkiverse.dapr + quarkus-dapr-deployment + ${quarkus-dapr.version} + + + io.quarkiverse.langchain4j + quarkus-langchain4j-agentic-deployment + ${quarkus-langchain4j.version} + + + io.quarkus + quarkus-arc-deployment + + + io.quarkus.gizmo + gizmo + + + io.dapr.quarkus + quarkus-agentic-dapr + ${project.version} + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.13.0 + + + + io.quarkus + quarkus-extension-processor + ${quarkus.version} + + + + + + + diff --git a/quarkus/deployment/src/main/java/io/quarkiverse/dapr/langchain4j/deployment/DaprAgenticProcessor.java b/quarkus/deployment/src/main/java/io/quarkiverse/dapr/langchain4j/deployment/DaprAgenticProcessor.java new file mode 100644 index 000000000..689a6fd81 --- /dev/null +++ b/quarkus/deployment/src/main/java/io/quarkiverse/dapr/langchain4j/deployment/DaprAgenticProcessor.java @@ -0,0 +1,647 @@ +/* + * Copyright 2025 The Dapr 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.quarkiverse.dapr.langchain4j.deployment; + +import io.quarkiverse.dapr.deployment.items.WorkflowItemBuildItem; +import io.quarkiverse.dapr.langchain4j.agent.AgentRunLifecycleManager; +import io.quarkiverse.dapr.langchain4j.agent.DaprAgentMetadataHolder; +import io.quarkus.arc.deployment.AdditionalBeanBuildItem; +import io.quarkus.arc.deployment.AnnotationsTransformerBuildItem; +import io.quarkus.arc.deployment.GeneratedBeanBuildItem; +import io.quarkus.arc.deployment.GeneratedBeanGizmoAdaptor; +import io.quarkus.arc.processor.AnnotationsTransformer; +import io.quarkus.deployment.annotations.BuildProducer; +import io.quarkus.deployment.annotations.BuildStep; +import io.quarkus.deployment.builditem.CombinedIndexBuildItem; +import io.quarkus.deployment.builditem.FeatureBuildItem; +import io.quarkus.deployment.builditem.IndexDependencyBuildItem; +import io.quarkus.gizmo.CatchBlockCreator; +import io.quarkus.gizmo.ClassCreator; +import io.quarkus.gizmo.ClassOutput; +import io.quarkus.gizmo.FieldCreator; +import io.quarkus.gizmo.FieldDescriptor; +import io.quarkus.gizmo.MethodCreator; +import io.quarkus.gizmo.MethodDescriptor; +import io.quarkus.gizmo.ResultHandle; +import io.quarkus.gizmo.TryBlock; +import jakarta.annotation.Priority; +import jakarta.decorator.Decorator; +import jakarta.decorator.Delegate; +import jakarta.enterprise.context.Dependent; +import jakarta.enterprise.inject.Any; +import jakarta.inject.Inject; +import jakarta.interceptor.Interceptor; +import org.jboss.jandex.AnnotationInstance; +import org.jboss.jandex.AnnotationTarget; +import org.jboss.jandex.AnnotationValue; +import org.jboss.jandex.ClassInfo; +import org.jboss.jandex.DotName; +import org.jboss.jandex.IndexView; +import org.jboss.jandex.MethodInfo; +import org.jboss.jandex.Type; +import org.jboss.logging.Logger; + +import java.lang.reflect.Modifier; +import java.util.HashSet; +import java.util.Set; + +/** + * Quarkus deployment processor for the Dapr Agentic extension. + * + *

{@code DaprWorkflowProcessor.searchWorkflows()} uses {@code ApplicationIndexBuildItem} + * which only indexes application classes -- extension runtime JARs are invisible to it. + * We fix this in two steps: + *

    + *
  1. Produce an {@link IndexDependencyBuildItem} so our runtime JAR is indexed into + * the {@link CombinedIndexBuildItem} (and visible to Arc for CDI bean discovery).
    2. + *
  2. Consume the {@link CombinedIndexBuildItem}, look up our Workflow and WorkflowActivity + * classes, and produce {@link WorkflowItemBuildItem} instances that the existing + * {@code DaprWorkflowProcessor} build steps consume to register with the Dapr + * workflow runtime.
    3. + *
  3. Produce {@link AdditionalBeanBuildItem} instances so Arc explicitly discovers + * our Workflow and WorkflowActivity classes as CDI beans.
    4. + *
  4. Apply {@code @DaprAgentToolInterceptorBinding} to all {@code @Tool}-annotated + * methods automatically so that {@code DaprToolCallInterceptor} routes those calls + * through Dapr Workflow Activities without requiring user code changes.
    5. + *
  5. Generate a CDI {@code @Decorator} for every {@code @Agent}-annotated interface + * so the {@link AgentRunLifecycleManager} workflow is started at the very beginning + * of the agent method call -- before LangChain4j assembles the prompt -- giving Dapr + * full observability of the agent's lifecycle from its first instruction.
    6. + *
+ */ +public class DaprAgenticProcessor { + + private static final Logger LOG = Logger.getLogger(DaprAgenticProcessor.class); + + private static final String FEATURE = "dapr-agentic"; + + /** + * Generated decorator classes live in this package to avoid polluting user packages. + */ + private static final String DECORATOR_PACKAGE = "io.quarkiverse.dapr.langchain4j.generated"; + + /** + * LangChain4j {@code @Tool} annotation (on CDI bean methods). + */ + private static final DotName TOOL_ANNOTATION = + DotName.createSimple("dev.langchain4j.agent.tool.Tool"); + + /** + * LangChain4j {@code @Agent} annotation (on AiService interface methods). + */ + private static final DotName AGENT_ANNOTATION = + DotName.createSimple("dev.langchain4j.agentic.Agent"); + + /** + * LangChain4j {@code @UserMessage} annotation. + */ + private static final DotName USER_MESSAGE_ANNOTATION = + DotName.createSimple("dev.langchain4j.service.UserMessage"); + + /** + * LangChain4j {@code @SystemMessage} annotation. + */ + private static final DotName SYSTEM_MESSAGE_ANNOTATION = + DotName.createSimple("dev.langchain4j.service.SystemMessage"); + + /** + * Our interceptor binding that triggers {@code DaprToolCallInterceptor}. + */ + private static final DotName DAPR_TOOL_INTERCEPTOR_BINDING = DotName.createSimple( + "io.quarkiverse.dapr.langchain4j.agent.DaprAgentToolInterceptorBinding"); + + /** + * Our interceptor binding that triggers {@code DaprAgentMethodInterceptor}. + */ + private static final DotName DAPR_AGENT_INTERCEPTOR_BINDING = DotName.createSimple( + "io.quarkiverse.dapr.langchain4j.agent.DaprAgentInterceptorBinding"); + + /** + * {@code @WorkflowMetadata} annotation for custom workflow registration names. + */ + private static final DotName WORKFLOW_METADATA_DOTNAME = DotName.createSimple( + "io.quarkiverse.dapr.workflows.WorkflowMetadata"); + + /** + * {@code @ActivityMetadata} annotation for custom activity registration names. + */ + private static final DotName ACTIVITY_METADATA_DOTNAME = DotName.createSimple( + "io.quarkiverse.dapr.workflows.ActivityMetadata"); + + private static final String[] WORKFLOW_CLASSES = { + "io.quarkiverse.dapr.langchain4j.workflow.orchestration.SequentialOrchestrationWorkflow", + "io.quarkiverse.dapr.langchain4j.workflow.orchestration.ParallelOrchestrationWorkflow", + "io.quarkiverse.dapr.langchain4j.workflow.orchestration.LoopOrchestrationWorkflow", + "io.quarkiverse.dapr.langchain4j.workflow.orchestration.ConditionalOrchestrationWorkflow", + // Per-agent workflow (one per @Agent invocation) + "io.quarkiverse.dapr.langchain4j.agent.workflow.AgentRunWorkflow", + }; + + private static final String[] ACTIVITY_CLASSES = { + "io.quarkiverse.dapr.langchain4j.workflow.orchestration.activities.AgentExecutionActivity", + "io.quarkiverse.dapr.langchain4j.workflow.orchestration.activities.ExitConditionCheckActivity", + "io.quarkiverse.dapr.langchain4j.workflow.orchestration.activities.ConditionCheckActivity", + // Per-tool-call activity + "io.quarkiverse.dapr.langchain4j.agent.activities.ToolCallActivity", + // Per-LLM-call activity + "io.quarkiverse.dapr.langchain4j.agent.activities.LlmCallActivity", + }; + + @BuildStep + FeatureBuildItem feature() { + return new FeatureBuildItem(FEATURE); + } + + /** + * Index our runtime JAR so its classes appear in {@link CombinedIndexBuildItem} + * and are discoverable by Arc for CDI bean creation. + */ + @BuildStep + IndexDependencyBuildItem indexRuntimeModule() { + return new IndexDependencyBuildItem("io.dapr.quarkus", "quarkus-agentic-dapr"); + } + + /** + * Produce {@link WorkflowItemBuildItem} for each of our Workflow and WorkflowActivity + * classes. + */ + @BuildStep + void registerWorkflowsAndActivities(CombinedIndexBuildItem combinedIndex, + BuildProducer workflowItems) { + IndexView index = combinedIndex.getIndex(); + + for (String className : WORKFLOW_CLASSES) { + ClassInfo classInfo = index.getClassByName(DotName.createSimple(className)); + if (classInfo != null) { + String regName = null; + String version = null; + Boolean isLatest = null; + AnnotationInstance meta = classInfo.annotation(WORKFLOW_METADATA_DOTNAME); + if (meta != null) { + regName = stringValueOrNull(meta, "name"); + version = stringValueOrNull(meta, "version"); + AnnotationValue isLatestVal = meta.value("isLatest"); + if (isLatestVal != null) { + isLatest = isLatestVal.asBoolean(); + } + } + workflowItems.produce(new WorkflowItemBuildItem( + classInfo, WorkflowItemBuildItem.Type.WORKFLOW, regName, version, isLatest)); + } + } + + for (String className : ACTIVITY_CLASSES) { + ClassInfo classInfo = index.getClassByName(DotName.createSimple(className)); + if (classInfo != null) { + String regName = null; + AnnotationInstance meta = classInfo.annotation(ACTIVITY_METADATA_DOTNAME); + if (meta != null) { + regName = stringValueOrNull(meta, "name"); + } + workflowItems.produce(new WorkflowItemBuildItem( + classInfo, WorkflowItemBuildItem.Type.WORKFLOW_ACTIVITY, regName, null, null)); + } + } + } + + /** + * Explicitly register our Workflow, WorkflowActivity, and CDI interceptor classes as beans. + */ + @BuildStep + void registerAdditionalBeans(BuildProducer additionalBeans) { + for (String className : WORKFLOW_CLASSES) { + additionalBeans.produce(AdditionalBeanBuildItem.unremovableOf(className)); + } + for (String className : ACTIVITY_CLASSES) { + additionalBeans.produce(AdditionalBeanBuildItem.unremovableOf(className)); + } + // AgentRunLifecycleManager is injected by generated decorators and must be discoverable. + additionalBeans.produce(AdditionalBeanBuildItem.unremovableOf( + AgentRunLifecycleManager.class.getName())); + // CDI interceptors must be registered as unremovable beans. + additionalBeans.produce(AdditionalBeanBuildItem.unremovableOf( + "io.quarkiverse.dapr.langchain4j.agent.DaprToolCallInterceptor")); + additionalBeans.produce(AdditionalBeanBuildItem.unremovableOf( + "io.quarkiverse.dapr.langchain4j.agent.DaprAgentMethodInterceptor")); + // CDI decorator that wraps ChatModel to route LLM calls through Dapr activities. + // A decorator is used instead of an interceptor because quarkus-langchain4j registers + // ChatModel as a synthetic bean, and Arc does not apply CDI interceptors to synthetic + // beans via AnnotationsTransformer -- but it DOES apply decorators at the type level. + additionalBeans.produce(AdditionalBeanBuildItem.unremovableOf( + "io.quarkiverse.dapr.langchain4j.agent.DaprChatModelDecorator")); + } + + /** + * Generates a CDI {@code @Decorator} for every interface that declares at least one + * {@code @Agent}-annotated method. + * + *

Why a generated decorator?

+ * quarkus-langchain4j registers {@code @Agent} AiService beans as synthetic beans + * (via {@code SyntheticBeanBuildItem}) -- CDI interceptors applied via + * {@code AnnotationsTransformer} are silently ignored on synthetic beans. CDI + * decorators, however, are matched at the bean type level and are applied + * by Arc to all beans (including synthetic beans) whose type includes the delegate type. + * This is the same mechanism used by + * {@link io.quarkiverse.dapr.langchain4j.agent.DaprChatModelDecorator} + * to wrap the synthetic {@code ChatModel} bean. + * + *

What the generated decorator does

+ * For each interface {@code I} with at least one {@code @Agent} method, Gizmo emits a class + * equivalent to: + * 
{@code
+   * @Decorator @Priority(APPLICATION) @Dependent
+   * class DaprDecorator_I implements I {
+   *   @Inject @Delegate @Any I delegate;
+   *   @Inject AgentRunLifecycleManager lifecycleManager;
+   *
+   *   @Override
+   *   ReturnType agentMethod(Params...) {
+   *     lifecycleManager.getOrActivate(agentName, userMessage, systemMessage);
+   *     try {
+   *       ReturnType result = delegate.agentMethod(params);
+   *       lifecycleManager.triggerDone();
+   *       return result;
+   *     } catch (Throwable t) {
+   *       lifecycleManager.triggerDone();
+   *       throw t;
+   *     }
+   *   }
+   *   // non-@Agent abstract methods: pure delegation to delegate
+   * }
+   * }
+ * + *

Non-{@code @Agent} abstract methods are delegated transparently. Static and default + * (non-abstract) interface methods are not overridden. + */ + @BuildStep + void generateAgentDecorators( + CombinedIndexBuildItem combinedIndex, + BuildProducer generatedBeans) { + + IndexView index = combinedIndex.getIndex(); + ClassOutput classOutput = new GeneratedBeanGizmoAdaptor(generatedBeans); + + Set processedInterfaces = new HashSet<>(); + + for (AnnotationInstance agentAnnotation : index.getAnnotations(AGENT_ANNOTATION)) { + if (agentAnnotation.target().kind() != AnnotationTarget.Kind.METHOD) { + continue; + } + + ClassInfo declaringClass = agentAnnotation.target().asMethod().declaringClass(); + + // Only generate decorators for interfaces. + // CDI bean classes with @Agent methods are handled by DaprAgentMethodInterceptor. + if (!declaringClass.isInterface()) { + continue; + } + + if (!processedInterfaces.add(declaringClass.name())) { + continue; // one decorator per interface + } + + generateDecorator(classOutput, index, declaringClass); + } + } + + // ------------------------------------------------------------------------- + // Decorator generation helpers + // ------------------------------------------------------------------------- + + private void generateDecorator(ClassOutput classOutput, IndexView index, + ClassInfo agentInterface) { + String interfaceName = agentInterface.name().toString(); + + // Use the fully-qualified interface name (dots replaced by underscores) so two + // interfaces with the same simple name in different packages never collide. + String decoratorClassName = DECORATOR_PACKAGE + ".DaprDecorator_" + + interfaceName.replace('.', '_'); + + LOG.debugf("Generating CDI decorator %s for @Agent interface %s", + decoratorClassName, interfaceName); + + try (ClassCreator cc = ClassCreator.builder() + .classOutput(classOutput) + .className(decoratorClassName) + .interfaces(interfaceName) + .build()) { + + // --- class-level CDI annotations --- + cc.addAnnotation(Decorator.class); + cc.addAnnotation(Dependent.class); + cc.addAnnotation(Priority.class) + .addValue("value", Interceptor.Priority.APPLICATION); + + // --- @Inject @Delegate @Any InterfaceType delegate --- + FieldCreator delegateField = cc.getFieldCreator("delegate", interfaceName); + delegateField.setModifiers(Modifier.PROTECTED); + delegateField.addAnnotation(Inject.class); + delegateField.addAnnotation(Delegate.class); + delegateField.addAnnotation(Any.class); + + // --- @Inject AgentRunLifecycleManager lifecycleManager --- + FieldCreator lcmField = cc.getFieldCreator("lifecycleManager", + AgentRunLifecycleManager.class.getName()); + lcmField.setModifiers(Modifier.PRIVATE); + lcmField.addAnnotation(Inject.class); + + FieldDescriptor delegateDesc = delegateField.getFieldDescriptor(); + FieldDescriptor lcmDesc = lcmField.getFieldDescriptor(); + + // --- method overrides --- + // Collect all abstract methods declared directly on this interface. + // Inherited abstract methods from parent interfaces are intentionally skipped: + // CDI decorators are allowed to be "partial" (not implement every inherited + // method); Arc will delegate un-overridden abstract methods to the next + // decorator/bean in the chain automatically. + for (MethodInfo method : agentInterface.methods()) { + // Skip static and default (non-abstract) interface methods. + if (Modifier.isStatic(method.flags()) + || !Modifier.isAbstract(method.flags())) { + continue; + } + + if (method.hasAnnotation(AGENT_ANNOTATION)) { + generateDecoratedAgentMethod(cc, method, delegateDesc, lcmDesc); + } else { + generateDelegateMethod(cc, method, delegateDesc); + } + } + } + } + + /** + * Generates the body for an {@code @Agent}-annotated method. + * 

+   *   lifecycleManager.getOrActivate(agentName, userMsg, sysMsg);
+   *   try {
+   *     [result =] delegate.method(params);
+   *     lifecycleManager.triggerDone();
+   *     return [result];           // or returnVoid()
+   *   } catch (Throwable t) {
+   *     lifecycleManager.triggerDone();
+   *     throw t;
+   *   }
+   *
+ */ + private void generateDecoratedAgentMethod(ClassCreator cc, MethodInfo method, + FieldDescriptor delegateDesc, FieldDescriptor lcmDesc) { + + String agentName = extractAgentName(method); + String userMessage = extractAnnotationText(method, USER_MESSAGE_ANNOTATION); + String systemMessage = extractAnnotationText(method, SYSTEM_MESSAGE_ANNOTATION); + final boolean isVoid = method.returnType().kind() == Type.Kind.VOID; + + MethodCreator mc = cc.getMethodCreator(MethodDescriptor.of(method)); + mc.setModifiers(Modifier.PUBLIC); + for (Type exType : method.exceptions()) { + mc.addException(exType.name().toString()); + } + + // Store @Agent metadata on the current thread so that DaprChatModelDecorator can + // retrieve the real agent name and messages if the activation below fails and the + // decorator falls through to direct delegation (lazy-activation path). + mc.invokeStaticMethod( + MethodDescriptor.ofMethod(DaprAgentMetadataHolder.class, "set", + void.class, String.class, String.class, String.class), + mc.load(agentName), + userMessage != null ? mc.load(userMessage) : mc.loadNull(), + systemMessage != null ? mc.load(systemMessage) : mc.loadNull()); + + // Try to activate the Dapr agent lifecycle. This may fail when running on + // threads without a CDI request scope (e.g., LangChain4j's parallel executor). + // In that case, fall through to a direct delegate call without Dapr routing. + TryBlock activateTry = mc.tryBlock(); + ResultHandle lcm = activateTry.readInstanceField(lcmDesc, activateTry.getThis()); + activateTry.invokeVirtualMethod( + MethodDescriptor.ofMethod(AgentRunLifecycleManager.class, "getOrActivate", + String.class, String.class, String.class, String.class), + lcm, + activateTry.load(agentName), + userMessage != null + ? activateTry.load(userMessage) : activateTry.loadNull(), + systemMessage != null + ? activateTry.load(systemMessage) : activateTry.loadNull()); + + // If activation fails (no request scope), delegate directly without Dapr routing. + CatchBlockCreator activateCatch = activateTry.addCatch(Throwable.class); + { + ResultHandle delFallback = activateCatch.readInstanceField( + delegateDesc, activateCatch.getThis()); + ResultHandle[] fallbackParams = new ResultHandle[method.parametersCount()]; + for (int i = 0; i < fallbackParams.length; i++) { + fallbackParams[i] = activateCatch.getMethodParam(i); + } + if (isVoid) { + activateCatch.invokeInterfaceMethod( + MethodDescriptor.of(method), delFallback, fallbackParams); + activateCatch.returnVoid(); + } else { + ResultHandle fallbackResult = activateCatch.invokeInterfaceMethod( + MethodDescriptor.of(method), delFallback, fallbackParams); + activateCatch.returnValue(fallbackResult); + } + } + + // Activation succeeded -- wrap the delegate call with triggerDone() on both paths. + // try { ... } catch (Throwable t) { ... } + TryBlock tryBlock = mc.tryBlock(); + + ResultHandle del = tryBlock.readInstanceField(delegateDesc, tryBlock.getThis()); + ResultHandle[] params = new ResultHandle[method.parametersCount()]; + for (int i = 0; i < params.length; i++) { + params[i] = tryBlock.getMethodParam(i); + } + + // Normal path: delegate call + triggerDone + return + ResultHandle result = null; + if (!isVoid) { + result = tryBlock.invokeInterfaceMethod( + MethodDescriptor.of(method), del, params); + } else { + tryBlock.invokeInterfaceMethod(MethodDescriptor.of(method), del, params); + } + + ResultHandle lcmInTry = tryBlock.readInstanceField(lcmDesc, tryBlock.getThis()); + tryBlock.invokeVirtualMethod( + MethodDescriptor.ofMethod( + AgentRunLifecycleManager.class, "triggerDone", void.class), + lcmInTry); + tryBlock.invokeStaticMethod( + MethodDescriptor.ofMethod(DaprAgentMetadataHolder.class, "clear", void.class)); + + if (isVoid) { + tryBlock.returnVoid(); + } else { + tryBlock.returnValue(result); + } + + // Exception path: triggerDone + rethrow + CatchBlockCreator catchBlock = tryBlock.addCatch(Throwable.class); + ResultHandle lcmInCatch = + catchBlock.readInstanceField(lcmDesc, catchBlock.getThis()); + catchBlock.invokeVirtualMethod( + MethodDescriptor.ofMethod( + AgentRunLifecycleManager.class, "triggerDone", void.class), + lcmInCatch); + catchBlock.invokeStaticMethod( + MethodDescriptor.ofMethod(DaprAgentMetadataHolder.class, "clear", void.class)); + catchBlock.throwException(catchBlock.getCaughtException()); + } + + /** + * Generates a trivial delegation body for non-{@code @Agent} abstract interface methods. + * 
+   *   return delegate.method(params);   // or just delegate.method(params); for void
+   *
+ */ + private void generateDelegateMethod(ClassCreator cc, MethodInfo method, + FieldDescriptor delegateDesc) { + + final boolean isVoid = method.returnType().kind() == Type.Kind.VOID; + + MethodCreator mc = cc.getMethodCreator(MethodDescriptor.of(method)); + mc.setModifiers(Modifier.PUBLIC); + for (Type exType : method.exceptions()) { + mc.addException(exType.name().toString()); + } + + ResultHandle del = mc.readInstanceField(delegateDesc, mc.getThis()); + ResultHandle[] params = new ResultHandle[method.parametersCount()]; + for (int i = 0; i < params.length; i++) { + params[i] = mc.getMethodParam(i); + } + + if (isVoid) { + mc.invokeInterfaceMethod(MethodDescriptor.of(method), del, params); + mc.returnVoid(); + } else { + ResultHandle result = mc.invokeInterfaceMethod( + MethodDescriptor.of(method), del, params); + mc.returnValue(result); + } + } + + // ------------------------------------------------------------------------- + // Annotation metadata extraction (Jandex) + // ------------------------------------------------------------------------- + + /** + * Returns the {@code @Agent(name)} value if non-blank, otherwise falls back to + * {@code InterfaceName.methodName}. + */ + private String extractAgentName(MethodInfo method) { + AnnotationInstance agent = method.annotation(AGENT_ANNOTATION); + if (agent != null) { + AnnotationValue nameVal = agent.value("name"); + if (nameVal != null && !nameVal.asString().isBlank()) { + return nameVal.asString(); + } + } + return method.declaringClass().name().withoutPackagePrefix() + + "." + method.name(); + } + + /** + * Returns the joined text of a {@code String[] value()} annotation attribute, or + * {@code null} when the annotation is absent or its value is empty. + * + *

Handles both the single-string form ({@code @UserMessage("text")}) and the + * array form ({@code @UserMessage({"line1", "line2"})}). + */ + private String extractAnnotationText(MethodInfo method, DotName annotationName) { + AnnotationInstance annotation = method.annotation(annotationName); + if (annotation == null) { + return null; + } + AnnotationValue value = annotation.value(); // "value" is the default attribute + if (value == null) { + return null; + } + if (value.kind() == AnnotationValue.Kind.ARRAY) { + String[] parts = value.asStringArray(); + return parts.length == 0 ? null : String.join("\n", parts); + } + // single String stored directly (rare but defensively handled) + return value.asString(); + } + + // ------------------------------------------------------------------------- + // Annotation metadata extraction helpers + // ------------------------------------------------------------------------- + + private static String stringValueOrNull(AnnotationInstance annotation, String name) { + AnnotationValue value = annotation.value(name); + if (value == null) { + return null; + } + String sv = value.asString(); + return (sv == null || sv.isEmpty()) ? null : sv; + } + + // ------------------------------------------------------------------------- + // Interceptor / annotation-transformer build steps (unchanged) + // ------------------------------------------------------------------------- + + /** + * Automatically apply {@code @DaprAgentToolInterceptorBinding} to every + * {@code @Tool}-annotated method in the application index. + */ + @BuildStep + @SuppressWarnings("deprecation") + AnnotationsTransformerBuildItem addDaprInterceptorToToolMethods() { + return new AnnotationsTransformerBuildItem( + AnnotationsTransformer.appliedToMethod() + .whenMethod(m -> m.hasAnnotation(TOOL_ANNOTATION)) + .thenTransform(t -> t.add(DAPR_TOOL_INTERCEPTOR_BINDING))); + } + + /** + * Automatically apply {@code @DaprAgentInterceptorBinding} to every + * {@code @Agent}-annotated method in the application index. + * + *

This causes {@link io.quarkiverse.dapr.langchain4j.agent.DaprAgentMethodInterceptor} + * to fire when an {@code @Agent} method is called on a regular CDI bean (not a synthetic + * AiService bean). For synthetic AiService beans the generated CDI decorator (produced by + * {@link #generateAgentDecorators}) is the authoritative hook point. + */ + @BuildStep + @SuppressWarnings("deprecation") + AnnotationsTransformerBuildItem addDaprInterceptorToAgentMethods() { + return new AnnotationsTransformerBuildItem( + AnnotationsTransformer.appliedToMethod() + .whenMethod(m -> m.hasAnnotation(AGENT_ANNOTATION)) + .thenTransform(t -> t.add(DAPR_AGENT_INTERCEPTOR_BINDING))); + } + + /** + * Also apply the interceptor binding at the class level for any CDI bean whose + * declared class itself has {@code @Tool} (less common but supported by LangChain4j). + */ + @BuildStep + @SuppressWarnings("deprecation") + AnnotationsTransformerBuildItem addDaprInterceptorToToolClasses() { + return new AnnotationsTransformerBuildItem( + AnnotationsTransformer.appliedToClass() + .whenClass(c -> { + for (MethodInfo method : c.methods()) { + if (method.hasAnnotation(TOOL_ANNOTATION)) { + return true; + } + } + return false; + }) + .thenTransform(t -> t.add(DAPR_TOOL_INTERCEPTOR_BINDING))); + } +} diff --git a/quarkus/examples/pom.xml b/quarkus/examples/pom.xml new file mode 100644 index 000000000..2e8ac2639 --- /dev/null +++ b/quarkus/examples/pom.xml @@ -0,0 +1,95 @@ + + + 4.0.0 + + io.dapr.quarkus + dapr-quarkus-agentic-parent + 1.18.0-SNAPSHOT + ../pom.xml + + + quarkus-agentic-dapr-examples + Quarkus Agentic Dapr - Examples + + + + + io.dapr.quarkus + quarkus-agentic-dapr + ${project.version} + + + + io.dapr.quarkus + quarkus-agentic-dapr-agents-registry + ${project.version} + + + + + io.quarkiverse.langchain4j + quarkus-langchain4j-openai + ${quarkus-langchain4j.version} + + + + + io.quarkus + quarkus-rest + + + + + io.quarkus + quarkus-junit5 + test + + + io.rest-assured + rest-assured + test + + + org.awaitility + awaitility + test + + + + + + + io.quarkus + quarkus-maven-plugin + ${quarkus.version} + + + + build + + + + + + maven-compiler-plugin + 3.13.0 + + + -parameters + + + + + maven-surefire-plugin + 3.5.2 + + + org.jboss.logmanager.LogManager + + + + + + diff --git a/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/CreativeWriter.java b/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/CreativeWriter.java new file mode 100644 index 000000000..ec67d9a47 --- /dev/null +++ b/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/CreativeWriter.java @@ -0,0 +1,35 @@ +/* + * Copyright 2025 The Dapr 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.quarkiverse.dapr.examples; + +import dev.langchain4j.agentic.Agent; +import dev.langchain4j.service.UserMessage; +import dev.langchain4j.service.V; +import io.quarkiverse.langchain4j.ToolBox; + +/** + * Sub-agent that generates a creative story draft based on a given topic. + */ +public interface CreativeWriter { + + @UserMessage(""" + You are a creative writer. + Generate a draft of a story no more than 3 sentences around the given topic. + Return only the story and nothing else. + The topic is {{topic}}. + """) + @Agent(name = "creative-writer-agent", + description = "Generate a story based on the given topic", outputKey = "story") + String generateStory(@V("topic") String topic); +} diff --git a/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/ParallelCreator.java b/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/ParallelCreator.java new file mode 100644 index 000000000..30277c329 --- /dev/null +++ b/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/ParallelCreator.java @@ -0,0 +1,50 @@ +/* + * Copyright 2025 The Dapr 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.quarkiverse.dapr.examples; + +import dev.langchain4j.agentic.declarative.Output; +import dev.langchain4j.agentic.declarative.ParallelAgent; +import dev.langchain4j.service.V; + +/** + * Composite agent that orchestrates {@link StoryCreator} and {@link ResearchWriter} + * in parallel, backed by a Dapr Workflow. + * + *

Both sub-agents execute concurrently via a {@code ParallelOrchestrationWorkflow}. + * {@link StoryCreator} is itself a {@code @SequenceAgent} that chains + * {@link CreativeWriter} and {@link StyleEditor} — demonstrating nested composite agents. + * Meanwhile {@link ResearchWriter} gathers facts about the country. + */ +public interface ParallelCreator { + + @ParallelAgent(name = "parallel-creator-agent", + outputKey = "storyAndCountryResearch", + subAgents = { StoryCreator.class, ResearchWriter.class }) + ParallelStatus create(@V("topic") String topic, @V("country") String country, @V("style") String style); + + /** + * Produces the final output from the parallel agent results. + * + * @param story the generated story + * @param summary the generated summary + * @return the combined parallel status + */ + @Output + static ParallelStatus output(String story, String summary) { + if (story == null || summary == null) { + return new ParallelStatus("ERROR", story, summary); + } + return new ParallelStatus("OK", story, summary); + } +} diff --git a/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/ParallelResource.java b/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/ParallelResource.java new file mode 100644 index 000000000..52a44879b --- /dev/null +++ b/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/ParallelResource.java @@ -0,0 +1,49 @@ +/* + * Copyright 2025 The Dapr 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.quarkiverse.dapr.examples; + +import jakarta.inject.Inject; +import jakarta.ws.rs.DefaultValue; +import jakarta.ws.rs.GET; +import jakarta.ws.rs.Path; +import jakarta.ws.rs.Produces; +import jakarta.ws.rs.QueryParam; +import jakarta.ws.rs.core.MediaType; + +/** + * REST endpoint that triggers the parallel creation workflow. + * + *

Runs {@link StoryCreator} (a nested {@code @SequenceAgent}) and {@link ResearchWriter} + * in parallel via a {@code ParallelOrchestrationWorkflow} Dapr Workflow. + * + *

Example usage: + * 

+ * curl "http://localhost:8080/parallel?topic=dragons&country=France&style=comedy"
+ *
+ */ +@Path("/parallel") +public class ParallelResource { + + @Inject + ParallelCreator parallelCreator; + + @GET + @Produces(MediaType.APPLICATION_JSON) + public ParallelStatus create( + @QueryParam("topic") @DefaultValue("dragons and wizards") String topic, + @QueryParam("country") @DefaultValue("France") String country, + @QueryParam("style") @DefaultValue("fantasy") String style) { + return parallelCreator.create(topic, country, style); + } +} diff --git a/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/ParallelStatus.java b/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/ParallelStatus.java new file mode 100644 index 000000000..f4737d3b3 --- /dev/null +++ b/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/ParallelStatus.java @@ -0,0 +1,17 @@ +/* + * Copyright 2025 The Dapr 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.quarkiverse.dapr.examples; + +public record ParallelStatus(String status, String story, String summary) { +} diff --git a/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/ResearchResource.java b/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/ResearchResource.java new file mode 100644 index 000000000..db3e5e4e6 --- /dev/null +++ b/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/ResearchResource.java @@ -0,0 +1,55 @@ +/* + * Copyright 2025 The Dapr 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.quarkiverse.dapr.examples; + +import jakarta.inject.Inject; +import jakarta.ws.rs.DefaultValue; +import jakarta.ws.rs.GET; +import jakarta.ws.rs.Path; +import jakarta.ws.rs.Produces; +import jakarta.ws.rs.QueryParam; +import jakarta.ws.rs.core.MediaType; + +/** + * REST endpoint that triggers a research workflow with tool calls routed through + * Dapr Workflow Activities. + * + *

Each request: + *

    + *
  1. Starts a {@code SequentialOrchestrationWorkflow} (orchestration level).
    2. + *
  2. For the {@link ResearchWriter} sub-agent, starts an {@code AgentRunWorkflow} + * (per-agent level).
    3. + *
  3. Each LLM tool call ({@code getPopulation} / {@code getCapital}) is executed + * inside a {@code ToolCallActivity} (tool-call level).
    4. + *
+ * + *

Example usage: + * 

+ * curl "http://localhost:8080/research?country=France"
+ * curl "http://localhost:8080/research?country=Germany"
+ *
+ */ +@Path("/research") +public class ResearchResource { + + @Inject + ResearchWriter researchWriter; + + @GET + @Produces(MediaType.TEXT_PLAIN) + public String research( + @QueryParam("country") @DefaultValue("France") String country) { + return researchWriter.research(country); + } +} diff --git a/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/ResearchTools.java b/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/ResearchTools.java new file mode 100644 index 000000000..9af9e2918 --- /dev/null +++ b/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/ResearchTools.java @@ -0,0 +1,70 @@ +/* + * Copyright 2025 The Dapr 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.quarkiverse.dapr.examples; + +import dev.langchain4j.agent.tool.Tool; +import jakarta.enterprise.context.ApplicationScoped; + +/** + * CDI bean providing research tools for the {@link ResearchWriter} agent. + * + *

Because the {@code quarkus-agentic-dapr} extension automatically applies + * {@code @DaprAgentToolInterceptorBinding} to all {@code @Tool}-annotated methods at + * build time, every call to these methods that occurs inside a Dapr-backed agent run is + * transparently routed through a {@code ToolCallActivity} Dapr Workflow Activity. + * + *

This means: + *

    + *
  • Each tool call is recorded in the Dapr Workflow history.
    • + *
  • If the process crashes during a tool call, Dapr retries the activity automatically.
    • + *
  • No code changes are needed here — the routing is applied automatically.
    • + *
+ */ +@ApplicationScoped +public class ResearchTools { + + /** + * Looks up real-time population data for a given country. + * + * @param country the country to look up + * @return population data string + */ + @Tool("Looks up real-time population data for a given country") + public String getPopulation(String country) { + // In a real implementation this would call an external API. + // Here we return a stub so the example runs without network access. + return switch (country.toLowerCase()) { + case "france" -> "France has approximately 68 million inhabitants (2024)."; + case "germany" -> "Germany has approximately 84 million inhabitants (2024)."; + case "japan" -> "Japan has approximately 124 million inhabitants (2024)."; + default -> country + " population data is not available in this demo."; + }; + } + + /** + * Returns the official capital city of a given country. + * + * @param country the country to look up + * @return capital city string + */ + @Tool("Returns the official capital city of a given country") + public String getCapital(String country) { + return switch (country.toLowerCase()) { + case "france" -> "The capital of France is Paris."; + case "germany" -> "The capital of Germany is Berlin."; + case "japan" -> "The capital of Japan is Tokyo."; + default -> "Capital city for " + country + " is not available in this demo."; + }; + } +} diff --git a/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/ResearchWriter.java b/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/ResearchWriter.java new file mode 100644 index 000000000..aa6f2c183 --- /dev/null +++ b/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/ResearchWriter.java @@ -0,0 +1,48 @@ +/* + * Copyright 2025 The Dapr 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.quarkiverse.dapr.examples; + +import dev.langchain4j.agentic.Agent; +import dev.langchain4j.service.UserMessage; +import dev.langchain4j.service.V; +import io.quarkiverse.langchain4j.ToolBox; + +/** + * Sub-agent that writes a short research summary about a country by calling tools. + * + *

The {@link ToolBox} annotation tells quarkus-langchain4j to make {@link ResearchTools} + * available to the LLM for this agent's method. When the LLM decides to call + * {@code getPopulation} or {@code getCapital}, the call is intercepted by the Dapr + * extension and executed inside a {@code ToolCallActivity} Dapr Workflow Activity — + * providing a durable, auditable record of every tool invocation. + * + *

Architecture note: No changes are required in this interface to enable the + * Dapr routing. The {@code quarkus-agentic-dapr} deployment module applies + * {@code @DaprAgentToolInterceptorBinding} to all {@code @Tool}-annotated methods at + * build time, and {@code DaprWorkflowPlanner} sets the per-agent context on the + * executing thread before the agent starts. + */ +public interface ResearchWriter { + + @ToolBox(ResearchTools.class) + @UserMessage(""" + You are a research assistant. + Write a concise 2-sentence summary about the country {{country}} + using the available tools to fetch accurate data. + Return only the summary. + """) + @Agent(name = "research-location-agent", + description = "Researches and summarises facts about a country", outputKey = "summary") + String research(@V("country") String country); +} diff --git a/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/StoryCreator.java b/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/StoryCreator.java new file mode 100644 index 000000000..26b6dd41e --- /dev/null +++ b/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/StoryCreator.java @@ -0,0 +1,32 @@ +/* + * Copyright 2025 The Dapr 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.quarkiverse.dapr.examples; + +import dev.langchain4j.agentic.declarative.SequenceAgent; +import dev.langchain4j.service.V; + +/** + * Composite agent that orchestrates {@link CreativeWriter} and {@link StyleEditor} + * in sequence, backed by a Dapr Workflow. + * + *

Uses {@code @SequenceAgent} which discovers the {@code DaprWorkflowAgentsBuilder} + * via Java SPI to create the Dapr Workflow-based sequential orchestration. + */ +public interface StoryCreator { + + @SequenceAgent(name = "story-creator-agent", + outputKey = "story", + subAgents = { CreativeWriter.class, StyleEditor.class }) + String write(@V("topic") String topic, @V("style") String style); +} diff --git a/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/StoryResource.java b/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/StoryResource.java new file mode 100644 index 000000000..afabf11f5 --- /dev/null +++ b/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/StoryResource.java @@ -0,0 +1,45 @@ +/* + * Copyright 2025 The Dapr 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.quarkiverse.dapr.examples; + +import jakarta.inject.Inject; +import jakarta.ws.rs.DefaultValue; +import jakarta.ws.rs.GET; +import jakarta.ws.rs.Path; +import jakarta.ws.rs.Produces; +import jakarta.ws.rs.QueryParam; +import jakarta.ws.rs.core.MediaType; + +/** + * REST endpoint that triggers the sequential story creation workflow. + * + *

Example usage: + * 

+ * curl "http://localhost:8080/story?topic=dragons&style=comedy"
+ *
+ */ +@Path("/story") +public class StoryResource { + + @Inject + StoryCreator storyCreator; + + @GET + @Produces(MediaType.TEXT_PLAIN) + public String createStory( + @QueryParam("topic") @DefaultValue("dragons and wizards") String topic, + @QueryParam("style") @DefaultValue("fantasy") String style) { + return storyCreator.write(topic, style); + } +} diff --git a/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/StyleEditor.java b/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/StyleEditor.java new file mode 100644 index 000000000..871c88d03 --- /dev/null +++ b/quarkus/examples/src/main/java/io/quarkiverse/dapr/examples/StyleEditor.java @@ -0,0 +1,34 @@ +/* + * Copyright 2025 The Dapr 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.quarkiverse.dapr.examples; + +import dev.langchain4j.agentic.Agent; +import dev.langchain4j.service.UserMessage; +import dev.langchain4j.service.V; + +/** + * Sub-agent that edits a story to improve its writing style. + */ +public interface StyleEditor { + + @UserMessage(""" + You are a style editor. + Review the following story and improve its style to match the requested style: {{style}}. + Return only the improved story and nothing else. + Story: {{story}} + """) + @Agent(name = "style-editor-agent", description = "Edit a story to improve its writing style", + outputKey = "story") + String editStory(@V("story") String story, @V("style") String style); +} diff --git a/quarkus/examples/src/main/resources/application.properties b/quarkus/examples/src/main/resources/application.properties new file mode 100644 index 000000000..a1c050062 --- /dev/null +++ b/quarkus/examples/src/main/resources/application.properties @@ -0,0 +1,26 @@ +# Dapr Dev Services (automatically starts Dapr sidecar, placement, scheduler, state store) +quarkus.dapr.devservices.enabled=true +quarkus.dapr.workflow.enabled=true +# OpenAI configuration +# Set your API key via environment variable: export OPENAI_API_KEY=sk-... +quarkus.langchain4j.openai.api-key=${OPENAI_API_KEY:demo} +quarkus.langchain4j.openai.chat-model.model-name=gpt-4o-mini + +quarkus.log.category."io.quarkiverse.dapr.agents.registry".level=DEBUG + +# OpenTelemetry Configuration +quarkus.otel.propagators=tracecontext,baggage + +# LangChain4j Tracing - gen_ai spans +quarkus.langchain4j.tracing.include-prompt=true +quarkus.langchain4j.tracing.include-completion=true +quarkus.langchain4j.tracing.include-tool-arguments=true +quarkus.langchain4j.tracing.include-tool-result=true + +# Dapr Workflows +quarkus.log.category."io.quarkiverse.dapr.workflows".level=DEBUG + + +#dapr.agents.statestore=agent-registry +#dapr.agents.team=default +#dapr.appid=agentic-example diff --git a/quarkus/examples/src/test/java/io/quarkiverse/dapr/examples/DaprWorkflowClientTest.java b/quarkus/examples/src/test/java/io/quarkiverse/dapr/examples/DaprWorkflowClientTest.java new file mode 100644 index 000000000..228152710 --- /dev/null +++ b/quarkus/examples/src/test/java/io/quarkiverse/dapr/examples/DaprWorkflowClientTest.java @@ -0,0 +1,28 @@ +package io.quarkiverse.dapr.examples; + +import static org.junit.jupiter.api.Assertions.assertNotNull; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; + +import io.dapr.workflows.client.DaprWorkflowClient; +import io.quarkus.test.junit.QuarkusTest; +import jakarta.inject.Inject; + +/** + * Verifies that the Dapr infrastructure is properly started by dev services. + * Tests that the DaprWorkflowClient CDI bean is available and connected + * to the Dapr sidecar backed by PostgreSQL state store. + */ +@QuarkusTest +@ExtendWith(DockerAvailableCondition.class) +class DaprWorkflowClientTest { + + @Inject + DaprWorkflowClient workflowClient; + + @Test + void daprWorkflowClientShouldBeAvailable() { + assertNotNull(workflowClient, "DaprWorkflowClient should be injected by Dapr dev services"); + } +} diff --git a/quarkus/examples/src/test/java/io/quarkiverse/dapr/examples/DockerAvailableCondition.java b/quarkus/examples/src/test/java/io/quarkiverse/dapr/examples/DockerAvailableCondition.java new file mode 100644 index 000000000..0747891d1 --- /dev/null +++ b/quarkus/examples/src/test/java/io/quarkiverse/dapr/examples/DockerAvailableCondition.java @@ -0,0 +1,48 @@ +package io.quarkiverse.dapr.examples; + +import java.io.File; + +import org.junit.jupiter.api.extension.ConditionEvaluationResult; +import org.junit.jupiter.api.extension.ExecutionCondition; +import org.junit.jupiter.api.extension.ExtensionContext; + +/** + * JUnit 5 {@link ExecutionCondition} that disables tests when Docker is not available. + * This prevents Dapr Testcontainers-based integration tests from failing in + * environments without Docker (e.g., CI without Docker-in-Docker). + *

+ * Checks for Docker by looking for the Docker socket file or running + * {@code docker info}. Usage: annotate test classes with + * {@code @ExtendWith(DockerAvailableCondition.class)}. + */ +public class DockerAvailableCondition implements ExecutionCondition { + + @Override + public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext context) { + // Check common Docker socket locations + if (new File("/var/run/docker.sock").exists()) { + return ConditionEvaluationResult.enabled("Docker socket found at /var/run/docker.sock"); + } + + // Try Docker Desktop on macOS + String home = System.getProperty("user.home"); + if (home != null && new File(home + "/.docker/run/docker.sock").exists()) { + return ConditionEvaluationResult.enabled("Docker socket found at ~/.docker/run/docker.sock"); + } + + // Fallback: try running 'docker info' + try { + Process process = new ProcessBuilder("docker", "info") + .redirectErrorStream(true) + .start(); + int exitCode = process.waitFor(); + if (exitCode == 0) { + return ConditionEvaluationResult.enabled("Docker is available (docker info succeeded)"); + } + } catch (Exception e) { + // docker command not found or failed + } + + return ConditionEvaluationResult.disabled("Docker is not available, skipping integration test"); + } +} diff --git a/quarkus/examples/src/test/java/io/quarkiverse/dapr/examples/MockChatModel.java b/quarkus/examples/src/test/java/io/quarkiverse/dapr/examples/MockChatModel.java new file mode 100644 index 000000000..2a0d4a232 --- /dev/null +++ b/quarkus/examples/src/test/java/io/quarkiverse/dapr/examples/MockChatModel.java @@ -0,0 +1,32 @@ +package io.quarkiverse.dapr.examples; + +import dev.langchain4j.data.message.AiMessage; +import dev.langchain4j.model.chat.ChatModel; +import dev.langchain4j.model.chat.request.ChatRequest; +import dev.langchain4j.model.chat.response.ChatResponse; +import dev.langchain4j.model.output.FinishReason; +import dev.langchain4j.model.output.TokenUsage; +import jakarta.annotation.Priority; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.enterprise.inject.Alternative; + +/** + * Mock ChatModel that returns predictable responses for integration testing. + * Takes priority over the OpenAI ChatModel bean via {@code @Alternative @Priority(1)}. + */ +@Alternative +@Priority(1) +@ApplicationScoped +public class MockChatModel implements ChatModel { + + @Override + public ChatResponse doChat(ChatRequest request) { + return ChatResponse.builder() + .aiMessage(AiMessage.from("Once upon a time, a brave dragon befriended a wizard. " + + "Together they embarked on an epic adventure across enchanted lands. " + + "Their story became legend, told for generations.")) + .tokenUsage(new TokenUsage(10, 30)) + .finishReason(FinishReason.STOP) + .build(); + } +} diff --git a/quarkus/examples/src/test/java/io/quarkiverse/dapr/examples/ParallelResourceTest.java b/quarkus/examples/src/test/java/io/quarkiverse/dapr/examples/ParallelResourceTest.java new file mode 100644 index 000000000..03ce2263e --- /dev/null +++ b/quarkus/examples/src/test/java/io/quarkiverse/dapr/examples/ParallelResourceTest.java @@ -0,0 +1,51 @@ +package io.quarkiverse.dapr.examples; + +import static io.restassured.RestAssured.given; +import static org.hamcrest.Matchers.equalTo; +import static org.hamcrest.Matchers.notNullValue; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; + +import io.quarkus.test.junit.QuarkusTest; + +/** + * Integration test for the parallel creation workflow. + *

+ * {@link ParallelCreator} runs {@link StoryCreator} (a nested {@code @SequenceAgent}) + * and {@link ResearchWriter} in parallel, verifying that nested composite agents work + * correctly with Dapr Workflows. + *

+ * Requires Docker for Dapr dev services. Uses {@link MockChatModel} instead of a real LLM. + */ +@QuarkusTest +@ExtendWith(DockerAvailableCondition.class) +class ParallelResourceTest { + + @Test + void testParallelEndpointReturnsResponse() { + given() + .queryParam("topic", "dragons") + .queryParam("country", "France") + .queryParam("style", "comedy") + .when() + .get("/parallel") + .then() + .statusCode(200) + .body("status", equalTo("OK")) + .body("story", notNullValue()) + .body("summary", notNullValue()); + } + + @Test + void testParallelEndpointWithDefaultParams() { + given() + .when() + .get("/parallel") + .then() + .statusCode(200) + .body("status", equalTo("OK")) + .body("story", notNullValue()) + .body("summary", notNullValue()); + } +} \ No newline at end of file diff --git a/quarkus/examples/src/test/java/io/quarkiverse/dapr/examples/StoryResourceTest.java b/quarkus/examples/src/test/java/io/quarkiverse/dapr/examples/StoryResourceTest.java new file mode 100644 index 000000000..d0d110bce --- /dev/null +++ b/quarkus/examples/src/test/java/io/quarkiverse/dapr/examples/StoryResourceTest.java @@ -0,0 +1,59 @@ +package io.quarkiverse.dapr.examples; + +import static io.restassured.RestAssured.given; +import static org.hamcrest.Matchers.notNullValue; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; + +import io.quarkus.test.junit.QuarkusTest; + +/** + * Integration test for the story creation workflow. + *

+ * Requires Docker for Dapr dev services (starts daprd, placement, scheduler, + * PostgreSQL state store, and dashboard containers via Testcontainers). + * Uses {@link MockChatModel} instead of a real LLM. + */ +@QuarkusTest +@ExtendWith(DockerAvailableCondition.class) +class StoryResourceTest { + + @Test + void testStoryEndpointReturnsResponse() { + given() + .queryParam("topic", "dragons") + .queryParam("style", "comedy") + .when() + .get("/story") + .then() + .statusCode(200) + .body(notNullValue()); + } + + @Test + void testStoryEndpointWithDefaultParams() { + given() + .when() + .get("/story") + .then() + .statusCode(200) + .body(notNullValue()); + } + + @Test + void testStoryEndpointResponseContainsContent() { + String body = given() + .queryParam("topic", "space exploration") + .queryParam("style", "sci-fi") + .when() + .get("/story") + .then() + .statusCode(200) + .extract() + .asString(); + + // The mock model always returns the same text; verify it's non-empty + assert !body.isBlank() : "Story response should not be blank"; + } +} diff --git a/quarkus/examples/src/test/resources/application.properties b/quarkus/examples/src/test/resources/application.properties new file mode 100644 index 000000000..e437b9459 --- /dev/null +++ b/quarkus/examples/src/test/resources/application.properties @@ -0,0 +1,8 @@ +# Dapr Dev Services with PostgreSQL state store (dashboard enabled = uses PostgreSQL) +quarkus.dapr.devservices.enabled=true +quarkus.dapr.devservices.dashboard.enabled=true +quarkus.dapr.workflow.enabled=true + +# Dummy OpenAI key (MockChatModel overrides the real provider in tests) +quarkus.langchain4j.openai.api-key=test-key +quarkus.langchain4j.openai.chat-model.model-name=gpt-4o-mini diff --git a/quarkus/pom.xml b/quarkus/pom.xml new file mode 100644 index 000000000..c15a341e5 --- /dev/null +++ b/quarkus/pom.xml @@ -0,0 +1,82 @@ + + + 4.0.0 + + + io.dapr + dapr-sdk-parent + 1.18.0-SNAPSHOT + ../pom.xml + + io.dapr.quarkus + dapr-quarkus-agentic-parent + + pom + Dapr Quarkus Agentic - Parent + + + runtime + deployment + quarkus-agentic-dapr-agents-registry + examples + + + + 17 + 17 + UTF-8 + 3.31.2 + 2.5.0 + 1.7.1 + + + + + + io.quarkus + quarkus-bom + ${quarkus.version} + pom + import + + + + commons-io + commons-io + 2.20.0 + + + + org.junit + junit-bom + 6.0.2 + pom + import + + + org.junit.jupiter + junit-jupiter + 6.0.2 + + + org.junit.jupiter + junit-jupiter-api + 6.0.2 + + + org.junit.jupiter + junit-jupiter-engine + 6.0.2 + + + + diff --git a/quarkus/quarkus-agentic-dapr-agents-registry/pom.xml b/quarkus/quarkus-agentic-dapr-agents-registry/pom.xml new file mode 100644 index 000000000..37f51de9b --- /dev/null +++ b/quarkus/quarkus-agentic-dapr-agents-registry/pom.xml @@ -0,0 +1,92 @@ + + + 4.0.0 + + io.dapr.quarkus + dapr-quarkus-agentic-parent + 1.18.0-SNAPSHOT + ../pom.xml + + + quarkus-agentic-dapr-agents-registry + Quarkus Agentic Dapr - Agent Registry + + + + io.quarkiverse.dapr + quarkus-dapr + ${quarkus-dapr.version} + + + com.fasterxml.jackson.core + jackson-databind + + + io.quarkiverse.langchain4j + quarkus-langchain4j-agentic + ${quarkus-langchain4j.version} + + + io.quarkus + quarkus-arc + + + org.junit.jupiter + junit-jupiter + test + + + org.assertj + assertj-core + 3.26.3 + test + + + org.mockito + mockito-core + 5.14.2 + test + + + io.quarkus + quarkus-junit + test + + + io.quarkiverse.langchain4j + quarkus-langchain4j-openai + ${quarkus-langchain4j.version} + test + + + org.awaitility + awaitility + test + + + + + + + maven-compiler-plugin + 3.13.0 + + + -parameters + + + + + maven-surefire-plugin + 3.5.2 + + + org.jboss.logmanager.LogManager + + + + + + diff --git a/quarkus/quarkus-agentic-dapr-agents-registry/src/main/java/io/quarkiverse/dapr/agents/registry/model/AgentMetadata.java b/quarkus/quarkus-agentic-dapr-agents-registry/src/main/java/io/quarkiverse/dapr/agents/registry/model/AgentMetadata.java new file mode 100644 index 000000000..3d4a5ca0b --- /dev/null +++ b/quarkus/quarkus-agentic-dapr-agents-registry/src/main/java/io/quarkiverse/dapr/agents/registry/model/AgentMetadata.java @@ -0,0 +1,172 @@ +/* + * Copyright 2025 The Dapr 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.quarkiverse.dapr.agents.registry.model; + +import com.fasterxml.jackson.annotation.JsonProperty; + +import java.util.List; + +public class AgentMetadata { + + @JsonProperty("appid") + private String appId; + + @JsonProperty("type") + private String type; + + @JsonProperty("orchestrator") + private boolean orchestrator; + + @JsonProperty("role") + private String role = ""; + + @JsonProperty("goal") + private String goal = ""; + + @JsonProperty("instructions") + private List instructions; + + @JsonProperty("statestore") + private String statestore; + + @JsonProperty("system_prompt") + private String systemPrompt; + + @JsonProperty("framework") + private String framework; + + public AgentMetadata() { + } + + private AgentMetadata(Builder builder) { + this.appId = builder.appId; + this.type = builder.type; + this.orchestrator = builder.orchestrator; + this.role = builder.role; + this.goal = builder.goal; + this.instructions = builder.instructions; + this.statestore = builder.statestore; + this.systemPrompt = builder.systemPrompt; + this.framework = builder.framework; + } + + public static Builder builder() { + return new Builder(); + } + + public String getAppId() { + return appId; + } + + public String getType() { + return type; + } + + public boolean isOrchestrator() { + return orchestrator; + } + + public String getRole() { + return role; + } + + public String getGoal() { + return goal; + } + + public List getInstructions() { + return instructions; + } + + public String getStatestore() { + return statestore; + } + + public String getSystemPrompt() { + return systemPrompt; + } + + public String getFramework() { + return framework; + } + + public static class Builder { + private String appId; + private String type; + private boolean orchestrator = false; + private String role = ""; + private String goal = ""; + private List instructions; + private String statestore; + private String systemPrompt; + private String framework; + + public Builder appId(String appId) { + this.appId = appId; + return this; + } + + public Builder type(String type) { + this.type = type; + return this; + } + + public Builder orchestrator(boolean orchestrator) { + this.orchestrator = orchestrator; + return this; + } + + public Builder role(String role) { + this.role = role; + return this; + } + + public Builder goal(String goal) { + this.goal = goal; + return this; + } + + public Builder instructions(List instructions) { + this.instructions = instructions; + return this; + } + + public Builder statestore(String statestore) { + this.statestore = statestore; + return this; + } + + public Builder systemPrompt(String systemPrompt) { + this.systemPrompt = systemPrompt; + return this; + } + + public Builder framework(String framework) { + this.framework = framework; + return this; + } + + /** + * Builds the AgentMetadata, validating required fields. + * + * @return the constructed AgentMetadata + */ + public AgentMetadata build() { + if (appId == null || type == null) { + throw new IllegalStateException("appId and type are required"); + } + return new AgentMetadata(this); + } + } +} diff --git a/quarkus/quarkus-agentic-dapr-agents-registry/src/main/java/io/quarkiverse/dapr/agents/registry/model/AgentMetadataSchema.java b/quarkus/quarkus-agentic-dapr-agents-registry/src/main/java/io/quarkiverse/dapr/agents/registry/model/AgentMetadataSchema.java new file mode 100644 index 000000000..e5572b6e3 --- /dev/null +++ b/quarkus/quarkus-agentic-dapr-agents-registry/src/main/java/io/quarkiverse/dapr/agents/registry/model/AgentMetadataSchema.java @@ -0,0 +1,232 @@ +/* + * Copyright 2025 The Dapr 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.quarkiverse.dapr.agents.registry.model; + +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +@JsonInclude(JsonInclude.Include.NON_NULL) +public class AgentMetadataSchema { + + @JsonProperty("schema_version") + private String schemaVersion; + + @JsonProperty("agent") + private AgentMetadata agent; + + @JsonProperty("name") + private String name; + + @JsonProperty("registered_at") + private String registeredAt; + + @JsonProperty("pubsub") + private PubSubMetadata pubsub; + + @JsonProperty("memory") + private MemoryMetadata memory; + + @JsonProperty("llm") + private LlmMetadata llm; + + @JsonProperty("registry") + private RegistryMetadata registry; + + @JsonProperty("tools") + private List tools; + + @JsonProperty("max_iterations") + private Integer maxIterations; + + @JsonProperty("tool_choice") + private String toolChoice; + + @JsonProperty("agent_metadata") + private Map agentMetadata; + + public AgentMetadataSchema() { + } + + private AgentMetadataSchema(Builder builder) { + this.schemaVersion = builder.schemaVersion; + this.agent = builder.agent; + this.name = builder.name; + this.registeredAt = builder.registeredAt; + this.pubsub = builder.pubsub; + this.memory = builder.memory; + this.llm = builder.llm; + this.registry = builder.registry; + this.tools = builder.tools; + this.maxIterations = builder.maxIterations; + this.toolChoice = builder.toolChoice; + this.agentMetadata = builder.agentMetadata; + } + + public static Builder builder() { + return new Builder(); + } + + public String getSchemaVersion() { + return schemaVersion; + } + + public AgentMetadata getAgent() { + return agent; + } + + public String getName() { + return name; + } + + public String getRegisteredAt() { + return registeredAt; + } + + public PubSubMetadata getPubsub() { + return pubsub; + } + + public MemoryMetadata getMemory() { + return memory; + } + + public LlmMetadata getLlm() { + return llm; + } + + public RegistryMetadata getRegistry() { + return registry; + } + + public List getTools() { + return tools; + } + + public Integer getMaxIterations() { + return maxIterations; + } + + public String getToolChoice() { + return toolChoice; + } + + public Map getAgentMetadata() { + return agentMetadata; + } + + public static class Builder { + private String schemaVersion; + private AgentMetadata agent; + private String name; + private String registeredAt; + private PubSubMetadata pubsub; + private MemoryMetadata memory; + private LlmMetadata llm; + private RegistryMetadata registry; + private List tools; + private Integer maxIterations; + private String toolChoice; + private Map agentMetadata; + + public Builder schemaVersion(String schemaVersion) { + this.schemaVersion = schemaVersion; + return this; + } + + public Builder agent(AgentMetadata agent) { + this.agent = agent; + return this; + } + + public Builder name(String name) { + this.name = name; + return this; + } + + public Builder registeredAt(String registeredAt) { + this.registeredAt = registeredAt; + return this; + } + + public Builder pubsub(PubSubMetadata pubsub) { + this.pubsub = pubsub; + return this; + } + + public Builder memory(MemoryMetadata memory) { + this.memory = memory; + return this; + } + + public Builder llm(LlmMetadata llm) { + this.llm = llm; + return this; + } + + public Builder registry(RegistryMetadata registry) { + this.registry = registry; + return this; + } + + public Builder tools(List tools) { + this.tools = tools; + return this; + } + + /** + * Adds a single tool to the tools list, initializing the list if needed. + * + * @param tool the tool metadata to add + * @return this builder + */ + public Builder addTool(ToolMetadata tool) { + if (this.tools == null) { + this.tools = new ArrayList<>(); + } + this.tools.add(tool); + return this; + } + + public Builder maxIterations(Integer maxIterations) { + this.maxIterations = maxIterations; + return this; + } + + public Builder toolChoice(String toolChoice) { + this.toolChoice = toolChoice; + return this; + } + + public Builder agentMetadata(Map agentMetadata) { + this.agentMetadata = agentMetadata; + return this; + } + + /** + * Builds the AgentMetadataSchema, validating required fields. + * + * @return the constructed AgentMetadataSchema + */ + public AgentMetadataSchema build() { + if (schemaVersion == null || agent == null || name == null || registeredAt == null) { + throw new IllegalStateException("schemaVersion, agent, name, and registeredAt are required"); + } + return new AgentMetadataSchema(this); + } + } +} diff --git a/quarkus/quarkus-agentic-dapr-agents-registry/src/main/java/io/quarkiverse/dapr/agents/registry/model/LlmMetadata.java b/quarkus/quarkus-agentic-dapr-agents-registry/src/main/java/io/quarkiverse/dapr/agents/registry/model/LlmMetadata.java new file mode 100644 index 000000000..d2cfdbb34 --- /dev/null +++ b/quarkus/quarkus-agentic-dapr-agents-registry/src/main/java/io/quarkiverse/dapr/agents/registry/model/LlmMetadata.java @@ -0,0 +1,170 @@ +/* + * Copyright 2025 The Dapr 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.quarkiverse.dapr.agents.registry.model; + +import com.fasterxml.jackson.annotation.JsonProperty; + +public class LlmMetadata { + + @JsonProperty("client") + private String client; + + @JsonProperty("provider") + private String provider; + + @JsonProperty("api") + private String api = "unknown"; + + @JsonProperty("model") + private String model = "unknown"; + + @JsonProperty("component_name") + private String componentName; + + @JsonProperty("base_url") + private String baseUrl; + + @JsonProperty("azure_endpoint") + private String azureEndpoint; + + @JsonProperty("azure_deployment") + private String azureDeployment; + + @JsonProperty("prompt_template") + private String promptTemplate; + + public LlmMetadata() { + } + + private LlmMetadata(Builder builder) { + this.client = builder.client; + this.provider = builder.provider; + this.api = builder.api; + this.model = builder.model; + this.componentName = builder.componentName; + this.baseUrl = builder.baseUrl; + this.azureEndpoint = builder.azureEndpoint; + this.azureDeployment = builder.azureDeployment; + this.promptTemplate = builder.promptTemplate; + } + + public static Builder builder() { + return new Builder(); + } + + public String getClient() { + return client; + } + + public String getProvider() { + return provider; + } + + public String getApi() { + return api; + } + + public String getModel() { + return model; + } + + public String getComponentName() { + return componentName; + } + + public String getBaseUrl() { + return baseUrl; + } + + public String getAzureEndpoint() { + return azureEndpoint; + } + + public String getAzureDeployment() { + return azureDeployment; + } + + public String getPromptTemplate() { + return promptTemplate; + } + + public static class Builder { + private String client; + private String provider; + private String api = "unknown"; + private String model = "unknown"; + private String componentName; + private String baseUrl; + private String azureEndpoint; + private String azureDeployment; + private String promptTemplate; + + public Builder client(String client) { + this.client = client; + return this; + } + + public Builder provider(String provider) { + this.provider = provider; + return this; + } + + public Builder api(String api) { + this.api = api; + return this; + } + + public Builder model(String model) { + this.model = model; + return this; + } + + public Builder componentName(String componentName) { + this.componentName = componentName; + return this; + } + + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + public Builder azureEndpoint(String azureEndpoint) { + this.azureEndpoint = azureEndpoint; + return this; + } + + public Builder azureDeployment(String azureDeployment) { + this.azureDeployment = azureDeployment; + return this; + } + + public Builder promptTemplate(String promptTemplate) { + this.promptTemplate = promptTemplate; + return this; + } + + /** + * Builds the LlmMetadata, validating required fields. + * + * @return the constructed LlmMetadata + */ + public LlmMetadata build() { + if (client == null || provider == null) { + throw new IllegalStateException("client and provider are required"); + } + return new LlmMetadata(this); + } + } +} diff --git a/quarkus/quarkus-agentic-dapr-agents-registry/src/main/java/io/quarkiverse/dapr/agents/registry/model/MemoryMetadata.java b/quarkus/quarkus-agentic-dapr-agents-registry/src/main/java/io/quarkiverse/dapr/agents/registry/model/MemoryMetadata.java new file mode 100644 index 000000000..57cc11031 --- /dev/null +++ b/quarkus/quarkus-agentic-dapr-agents-registry/src/main/java/io/quarkiverse/dapr/agents/registry/model/MemoryMetadata.java @@ -0,0 +1,72 @@ +/* + * Copyright 2025 The Dapr 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.quarkiverse.dapr.agents.registry.model; + +import com.fasterxml.jackson.annotation.JsonProperty; + +public class MemoryMetadata { + + @JsonProperty("type") + private String type; + + @JsonProperty("statestore") + private String statestore; + + public MemoryMetadata() { + } + + private MemoryMetadata(Builder builder) { + this.type = builder.type; + this.statestore = builder.statestore; + } + + public static Builder builder() { + return new Builder(); + } + + public String getType() { + return type; + } + + public String getStatestore() { + return statestore; + } + + public static class Builder { + private String type; + private String statestore; + + public Builder type(String type) { + this.type = type; + return this; + } + + public Builder statestore(String statestore) { + this.statestore = statestore; + return this; + } + + /** + * Builds a new MemoryMetadata instance. + * + * @return the built MemoryMetadata + */ + public MemoryMetadata build() { + if (type == null) { + throw new IllegalStateException("type is required"); + } + return new MemoryMetadata(this); + } + } +} diff --git a/quarkus/quarkus-agentic-dapr-agents-registry/src/main/java/io/quarkiverse/dapr/agents/registry/model/PubSubMetadata.java b/quarkus/quarkus-agentic-dapr-agents-registry/src/main/java/io/quarkiverse/dapr/agents/registry/model/PubSubMetadata.java new file mode 100644 index 000000000..1a844c18b --- /dev/null +++ b/quarkus/quarkus-agentic-dapr-agents-registry/src/main/java/io/quarkiverse/dapr/agents/registry/model/PubSubMetadata.java @@ -0,0 +1,86 @@ +/* + * Copyright 2025 The Dapr 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.quarkiverse.dapr.agents.registry.model; + +import com.fasterxml.jackson.annotation.JsonProperty; + +public class PubSubMetadata { + + @JsonProperty("name") + private String name; + + @JsonProperty("broadcast_topic") + private String broadcastTopic; + + @JsonProperty("agent_topic") + private String agentTopic; + + public PubSubMetadata() { + } + + private PubSubMetadata(Builder builder) { + this.name = builder.name; + this.broadcastTopic = builder.broadcastTopic; + this.agentTopic = builder.agentTopic; + } + + public static Builder builder() { + return new Builder(); + } + + public String getName() { + return name; + } + + public String getBroadcastTopic() { + return broadcastTopic; + } + + public String getAgentTopic() { + return agentTopic; + } + + public static class Builder { + private String name; + private String broadcastTopic; + private String agentTopic; + + public Builder name(String name) { + this.name = name; + return this; + } + + public Builder broadcastTopic(String broadcastTopic) { + this.broadcastTopic = broadcastTopic; + return this; + } + + public Builder agentTopic(String agentTopic) { + this.agentTopic = agentTopic; + return this; + } + + /** + * Builds a new PubSubMetadata instance. + * + * @return the built PubSubMetadata + */ + public PubSubMetadata build() { + if (name == null) { + throw new IllegalStateException("name is required"); + } + return new PubSubMetadata(this); + } + } +} diff --git a/quarkus/quarkus-agentic-dapr-agents-registry/src/main/java/io/quarkiverse/dapr/agents/registry/model/RegistryMetadata.java b/quarkus/quarkus-agentic-dapr-agents-registry/src/main/java/io/quarkiverse/dapr/agents/registry/model/RegistryMetadata.java new file mode 100644 index 000000000..3ca17bc54 --- /dev/null +++ b/quarkus/quarkus-agentic-dapr-agents-registry/src/main/java/io/quarkiverse/dapr/agents/registry/model/RegistryMetadata.java @@ -0,0 +1,64 @@ +/* + * Copyright 2025 The Dapr 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.quarkiverse.dapr.agents.registry.model; + +import com.fasterxml.jackson.annotation.JsonProperty; + +public class RegistryMetadata { + + @JsonProperty("statestore") + private String statestore; + + @JsonProperty("name") + private String name; + + public RegistryMetadata() { + } + + private RegistryMetadata(Builder builder) { + this.statestore = builder.statestore; + this.name = builder.name; + } + + public static Builder builder() { + return new Builder(); + } + + public String getStatestore() { + return statestore; + } + + public String getName() { + return name; + } + + public static class Builder { + private String statestore; + private String name; + + public Builder statestore(String statestore) { + this.statestore = statestore; + return this; + } + + public Builder name(String name) { + this.name = name; + return this; + } + + public RegistryMetadata build() { + return new RegistryMetadata(this); + } + } +} diff --git a/quarkus/quarkus-agentic-dapr-agents-registry/src/main/java/io/quarkiverse/dapr/agents/registry/model/ToolMetadata.java b/quarkus/quarkus-agentic-dapr-agents-registry/src/main/java/io/quarkiverse/dapr/agents/registry/model/ToolMetadata.java new file mode 100644 index 000000000..cca5a0a68 --- /dev/null +++ b/quarkus/quarkus-agentic-dapr-agents-registry/src/main/java/io/quarkiverse/dapr/agents/registry/model/ToolMetadata.java @@ -0,0 +1,86 @@ +/* + * Copyright 2025 The Dapr 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.quarkiverse.dapr.agents.registry.model; + +import com.fasterxml.jackson.annotation.JsonProperty; + +public class ToolMetadata { + + @JsonProperty("tool_name") + private String toolName; + + @JsonProperty("tool_description") + private String toolDescription; + + @JsonProperty("tool_args") + private String toolArgs; + + public ToolMetadata() { + } + + private ToolMetadata(Builder builder) { + this.toolName = builder.toolName; + this.toolDescription = builder.toolDescription; + this.toolArgs = builder.toolArgs; + } + + public static Builder builder() { + return new Builder(); + } + + public String getToolName() { + return toolName; + } + + public String getToolDescription() { + return toolDescription; + } + + public String getToolArgs() { + return toolArgs; + } + + public static class Builder { + private String toolName; + private String toolDescription; + private String toolArgs; + + public Builder toolName(String toolName) { + this.toolName = toolName; + return this; + } + + public Builder toolDescription(String toolDescription) { + this.toolDescription = toolDescription; + return this; + } + + public Builder toolArgs(String toolArgs) { + this.toolArgs = toolArgs; + return this; + } + + /** + * Builds the ToolMetadata, validating required fields. + * + * @return the constructed ToolMetadata + */ + public ToolMetadata build() { + if (toolName == null || toolDescription == null || toolArgs == null) { + throw new IllegalStateException("toolName, toolDescription, and toolArgs are required"); + } + return new ToolMetadata(this); + } + } +} diff --git a/quarkus/quarkus-agentic-dapr-agents-registry/src/main/java/io/quarkiverse/dapr/agents/registry/service/AgentRegistry.java b/quarkus/quarkus-agentic-dapr-agents-registry/src/main/java/io/quarkiverse/dapr/agents/registry/service/AgentRegistry.java new file mode 100644 index 000000000..0be11bb9c --- /dev/null +++ b/quarkus/quarkus-agentic-dapr-agents-registry/src/main/java/io/quarkiverse/dapr/agents/registry/service/AgentRegistry.java @@ -0,0 +1,267 @@ +/* + * Copyright 2025 The Dapr 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.quarkiverse.dapr.agents.registry.service; + +import io.dapr.client.DaprClient; +import io.quarkiverse.dapr.agents.registry.model.AgentMetadata; +import io.quarkiverse.dapr.agents.registry.model.AgentMetadataSchema; +import io.quarkus.runtime.StartupEvent; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.enterprise.event.Observes; +import jakarta.enterprise.inject.Any; +import jakarta.enterprise.inject.spi.Bean; +import jakarta.enterprise.inject.spi.BeanManager; +import jakarta.inject.Inject; +import org.eclipse.microprofile.config.inject.ConfigProperty; +import org.jboss.logging.Logger; + +import java.lang.annotation.Annotation; +import java.lang.reflect.Method; +import java.lang.reflect.Type; +import java.time.Instant; +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +@ApplicationScoped +public class AgentRegistry { + + private static final Logger LOG = Logger.getLogger(AgentRegistry.class); + + /** + * Fully-qualified name of langchain4j {@code @Agent} annotation. + */ + private static final String AGENT_ANNOTATION_NAME = "dev.langchain4j.agentic.Agent"; + + /** + * Fully-qualified name of langchain4j {@code @SystemMessage} annotation. + */ + private static final String SYSTEM_MESSAGE_ANNOTATION_NAME = "dev.langchain4j.service.SystemMessage"; + + @Inject + DaprClient client; + + @Inject + BeanManager beanManager; + + @ConfigProperty(name = "dapr.agents.statestore", defaultValue = "kvstore") + String statestore; + + @ConfigProperty(name = "dapr.appid", defaultValue = "local-dapr-app") + String appId; + + @ConfigProperty(name = "dapr.agents.team", defaultValue = "default") + String team; + + void onStartup(@Observes StartupEvent event) { + discoverAndRegisterAgents(); + } + + void discoverAndRegisterAgents() { + LOG.info("Starting agent auto-discovery..."); + Set> beans = beanManager.getBeans(Object.class, Any.Literal.INSTANCE); + LOG.debugf("Found %d CDI beans to scan", beans.size()); + + Set scannedInterfaces = new HashSet<>(); + // Collect all interface classes from CDI beans first + List> interfacesToScan = new ArrayList<>(); + + for (Bean bean : beans) { + for (Type type : bean.getTypes()) { + if (type instanceof Class clazz && clazz.isInterface()) { + if (scannedInterfaces.add(clazz.getName())) { + interfacesToScan.add(clazz); + } + } + } + } + + // Also discover sub-agent classes referenced by composite agent annotations + // (e.g., @SequenceAgent(subAgents = {CreativeWriter.class, StyleEditor.class})). + // Sub-agents are often not CDI beans themselves, so they won't appear in BeanManager. + List> subAgentClasses = new ArrayList<>(); + for (Class iface : interfacesToScan) { + for (Method method : iface.getDeclaredMethods()) { + for (Annotation ann : method.getDeclaredAnnotations()) { + for (Class subAgent : extractSubAgentClasses(ann)) { + if (subAgent.isInterface() && scannedInterfaces.add(subAgent.getName())) { + subAgentClasses.add(subAgent); + LOG.debugf("Discovered sub-agent interface %s from %s on %s", + subAgent.getName(), ann.annotationType().getSimpleName(), iface.getName()); + } + } + } + } + } + interfacesToScan.addAll(subAgentClasses); + + // Scan all collected interfaces for @Agent methods + int registered = 0; + int failed = 0; + for (Class iface : interfacesToScan) { + LOG.debugf("Scanning interface: %s", iface.getName()); + List agents = scanForAgents(iface, appId); + if (!agents.isEmpty()) { + LOG.debugf("Found %d @Agent method(s) on interface %s", agents.size(), iface.getName()); + } + for (AgentMetadataSchema schema : agents) { + try { + registerAgent(schema); + registered++; + } catch (Exception e) { + failed++; + LOG.errorf(e, "Failed to register agent '%s' in state store '%s': %s", + schema.getName(), statestore, e.getMessage()); + } + } + } + + LOG.debugf("Scanned %d unique interfaces", scannedInterfaces.size()); + + if (registered == 0 && failed == 0) { + LOG.warn("No @Agent-annotated methods found on any CDI bean interface. " + + "Ensure your @Agent interfaces are registered as CDI beans."); + } else if (failed > 0) { + LOG.warnf("Agent discovery complete: %d registered, %d failed", registered, failed); + } else { + LOG.infof("Agent discovery complete: %d agent(s) registered successfully", registered); + } + } + + /** + * Extracts sub-agent classes from a composite agent annotation. + * + *

Looks for a {@code subAgents()} method returning {@code Class[]} on the annotation. + * This works for any composite agent annotation (e.g., {@code @SequenceAgent}, + * {@code @ParallelAgent}, etc.) without coupling to specific annotation types. + */ + static Class[] extractSubAgentClasses(Annotation ann) { + try { + Method subAgentsMethod = ann.annotationType().getMethod("subAgents"); + Object result = subAgentsMethod.invoke(ann); + if (result instanceof Class[] classes) { + return classes; + } + } catch (NoSuchMethodException e) { + // Not a composite agent annotation — expected for most annotations + } catch (Exception e) { + LOG.debugf("Failed to extract subAgents from %s: %s", + ann.annotationType().getSimpleName(), e.getMessage()); + } + return new Class[0]; + } + + /** + * Scans an interface for methods annotated with {@code @Agent} and extracts metadata. + * + *

Uses name-based annotation matching ({@code annotationType().getName()}) instead of + * class identity ({@code method.getAnnotation(Agent.class)}) to handle classloader + * differences between library JARs and the Quarkus application classloader. + */ + static List scanForAgents(Class type, String appId) { + List result = new ArrayList<>(); + for (Method method : type.getDeclaredMethods()) { + Annotation agentAnn = findAnnotationByName(method, AGENT_ANNOTATION_NAME); + if (agentAnn == null) { + continue; + } + + String name = invokeStringMethod(agentAnn, "name"); + if (name == null || name.isBlank()) { + name = type.getSimpleName() + "." + method.getName(); + } + + String goal = invokeStringMethod(agentAnn, "description"); + + String systemPrompt = null; + Annotation smAnn = findAnnotationByName(method, SYSTEM_MESSAGE_ANNOTATION_NAME); + if (smAnn != null) { + String[] values = invokeMethod(smAnn, "value", String[].class); + String delimiter = invokeStringMethod(smAnn, "delimiter"); + if (values != null && values.length > 0) { + String joined = String.join(delimiter != null ? delimiter : "\n", values); + if (!joined.isBlank()) { + systemPrompt = joined; + } + } + } + + AgentMetadataSchema schema = AgentMetadataSchema.builder() + .schemaVersion("0.11.1") + .name(name) + .registeredAt(Instant.now().toString()) + .agent(AgentMetadata.builder() + .appId(appId) + .type("standalone") + .goal(goal) + .systemPrompt(systemPrompt) + .framework("langchain4j") + .build()) + .build(); + + result.add(schema); + } + return result; + } + + /** + * Finds an annotation on a method by its fully-qualified type name. + * This is resilient against classloader mismatches where the same annotation class + * may be loaded by different classloaders. + */ + private static Annotation findAnnotationByName(Method method, String annotationName) { + for (Annotation ann : method.getDeclaredAnnotations()) { + if (ann.annotationType().getName().equals(annotationName)) { + return ann; + } + } + return null; + } + + /** + * Invokes a no-arg method on an annotation proxy and returns the result as a String. + */ + private static String invokeStringMethod(Annotation ann, String methodName) { + return invokeMethod(ann, methodName, String.class); + } + + /** + * Invokes a no-arg method on an annotation proxy, casting to the expected type. + */ + @SuppressWarnings("unchecked") + private static T invokeMethod(Annotation ann, String methodName, Class returnType) { + try { + Object result = ann.annotationType().getMethod(methodName).invoke(ann); + return returnType.isInstance(result) ? (T) result : null; + } catch (Exception e) { + LOG.debugf("Failed to invoke %s.%s(): %s", + ann.annotationType().getSimpleName(), methodName, e.getMessage()); + return null; + } + } + + /** + * Registers an agent schema in the Dapr state store. + * + * @param schema the agent metadata schema to register + */ + public void registerAgent(AgentMetadataSchema schema) { + String key = "agents:" + team + ":" + schema.getName(); + LOG.infof("Registering agent: %s", key); + client.saveState(statestore, key, null, schema, + Map.of("contentType", "application/json"), null).block(); + } +} diff --git a/quarkus/quarkus-agentic-dapr-agents-registry/src/main/resources/META-INF/beans.xml b/quarkus/quarkus-agentic-dapr-agents-registry/src/main/resources/META-INF/beans.xml new file mode 100644 index 000000000..162171f0f --- /dev/null +++ b/quarkus/quarkus-agentic-dapr-agents-registry/src/main/resources/META-INF/beans.xml @@ -0,0 +1,6 @@ + + + diff --git a/quarkus/quarkus-agentic-dapr-agents-registry/src/main/resources/schema.json b/quarkus/quarkus-agentic-dapr-agents-registry/src/main/resources/schema.json new file mode 100644 index 000000000..5e926ac93 --- /dev/null +++ b/quarkus/quarkus-agentic-dapr-agents-registry/src/main/resources/schema.json @@ -0,0 +1,461 @@ +{ + "$defs": { + "AgentMetadata": { + "description": "Metadata about an agent's configuration and capabilities.", + "properties": { + "appid": { + "description": "Dapr application ID of the agent", + "title": "Appid", + "type": "string" + }, + "type": { + "description": "Type of the agent (e.g., standalone, durable)", + "title": "Type", + "type": "string" + }, + "orchestrator": { + "default": false, + "description": "Indicates if the agent is an orchestrator", + "title": "Orchestrator", + "type": "boolean" + }, + "role": { + "default": "", + "description": "Role of the agent", + "title": "Role", + "type": "string" + }, + "goal": { + "default": "", + "description": "High-level objective of the agent", + "title": "Goal", + "type": "string" + }, + "instructions": { + "anyOf": [ + { + "items": { + "type": "string" + }, + "type": "array" + }, + { + "type": "null" + } + ], + "default": null, + "description": "Instructions for the agent", + "title": "Instructions" + }, + "statestore": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "default": null, + "description": "Dapr state store component name used by the agent", + "title": "Statestore" + }, + "system_prompt": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "default": null, + "description": "System prompt guiding the agent's behavior", + "title": "System Prompt" + }, + "framework": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "default": null, + "description": "Framework or library the agent is built with", + "title": "Framework" + } + }, + "required": [ + "appid", + "type" + ], + "title": "AgentMetadata", + "type": "object" + }, + "LLMMetadata": { + "description": "LLM configuration information.", + "properties": { + "client": { + "description": "LLM client used by the agent", + "title": "Client", + "type": "string" + }, + "provider": { + "description": "LLM provider used by the agent", + "title": "Provider", + "type": "string" + }, + "api": { + "default": "unknown", + "description": "API type used by the LLM client", + "title": "Api", + "type": "string" + }, + "model": { + "default": "unknown", + "description": "Model name or identifier", + "title": "Model", + "type": "string" + }, + "component_name": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "default": null, + "description": "Dapr component name for the LLM client", + "title": "Component Name" + }, + "base_url": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "default": null, + "description": "Base URL for the LLM API if applicable", + "title": "Base Url" + }, + "azure_endpoint": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "default": null, + "description": "Azure endpoint if using Azure OpenAI", + "title": "Azure Endpoint" + }, + "azure_deployment": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "default": null, + "description": "Azure deployment name if using Azure OpenAI", + "title": "Azure Deployment" + }, + "prompt_template": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "default": null, + "description": "Prompt template used by the agent", + "title": "Prompt Template" + } + }, + "required": [ + "client", + "provider" + ], + "title": "LLMMetadata", + "type": "object" + }, + "MemoryMetadata": { + "description": "Memory configuration information.", + "properties": { + "type": { + "description": "Type of memory used by the agent", + "title": "Type", + "type": "string" + }, + "statestore": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "default": null, + "description": "Dapr state store component name for memory", + "title": "Statestore" + } + }, + "required": [ + "type" + ], + "title": "MemoryMetadata", + "type": "object" + }, + "PubSubMetadata": { + "description": "Pub/Sub configuration information.", + "properties": { + "name": { + "description": "Pub/Sub component name", + "title": "Name", + "type": "string" + }, + "broadcast_topic": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "default": null, + "description": "Pub/Sub topic for broadcasting messages", + "title": "Broadcast Topic" + }, + "agent_topic": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "default": null, + "description": "Pub/Sub topic for direct agent messages", + "title": "Agent Topic" + } + }, + "required": [ + "name" + ], + "title": "PubSubMetadata", + "type": "object" + }, + "RegistryMetadata": { + "description": "Registry configuration information.", + "properties": { + "statestore": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "default": null, + "description": "Name of the statestore component for the registry", + "title": "Statestore" + }, + "name": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "default": null, + "description": "Name of the team registry", + "title": "Name" + } + }, + "title": "RegistryMetadata", + "type": "object" + }, + "ToolMetadata": { + "description": "Metadata about a tool available to the agent.", + "properties": { + "tool_name": { + "description": "Name of the tool", + "title": "Tool Name", + "type": "string" + }, + "tool_description": { + "description": "Description of the tool's functionality", + "title": "Tool Description", + "type": "string" + }, + "tool_args": { + "description": "Arguments for the tool", + "title": "Tool Args", + "type": "string" + } + }, + "required": [ + "tool_name", + "tool_description", + "tool_args" + ], + "title": "ToolMetadata", + "type": "object" + } + }, + "description": "Schema for agent metadata including schema version.", + "properties": { + "schema_version": { + "description": "Version of the schema used for the agent metadata.", + "title": "Schema Version", + "type": "string" + }, + "agent": { + "$ref": "#/$defs/AgentMetadata", + "description": "Agent configuration and capabilities" + }, + "name": { + "description": "Name of the agent", + "title": "Name", + "type": "string" + }, + "registered_at": { + "description": "ISO 8601 timestamp of registration", + "title": "Registered At", + "type": "string" + }, + "pubsub": { + "anyOf": [ + { + "$ref": "#/$defs/PubSubMetadata" + }, + { + "type": "null" + } + ], + "default": null, + "description": "Pub/sub configuration if enabled" + }, + "memory": { + "anyOf": [ + { + "$ref": "#/$defs/MemoryMetadata" + }, + { + "type": "null" + } + ], + "default": null, + "description": "Memory configuration if enabled" + }, + "llm": { + "anyOf": [ + { + "$ref": "#/$defs/LLMMetadata" + }, + { + "type": "null" + } + ], + "default": null, + "description": "LLM configuration" + }, + "registry": { + "anyOf": [ + { + "$ref": "#/$defs/RegistryMetadata" + }, + { + "type": "null" + } + ], + "default": null, + "description": "Registry configuration" + }, + "tools": { + "anyOf": [ + { + "items": { + "$ref": "#/$defs/ToolMetadata" + }, + "type": "array" + }, + { + "type": "null" + } + ], + "default": null, + "description": "Available tools", + "title": "Tools" + }, + "max_iterations": { + "anyOf": [ + { + "type": "integer" + }, + { + "type": "null" + } + ], + "default": null, + "description": "Maximum iterations for agent execution", + "title": "Max Iterations" + }, + "tool_choice": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "default": null, + "description": "Tool choice strategy", + "title": "Tool Choice" + }, + "agent_metadata": { + "anyOf": [ + { + "additionalProperties": true, + "type": "object" + }, + { + "type": "null" + } + ], + "default": null, + "description": "Additional metadata about the agent", + "title": "Agent Metadata" + } + }, + "required": [ + "schema_version", + "agent", + "name", + "registered_at" + ], + "title": "AgentMetadataSchema", + "type": "object", + "$schema": "https://json-schema.org/draft/2020-12/schema", + "version": "0.11.1" +} \ No newline at end of file diff --git a/quarkus/quarkus-agentic-dapr-agents-registry/src/test/java/io/quarkiverse/dapr/agents/registry/model/AgentMetadataSchemaTest.java b/quarkus/quarkus-agentic-dapr-agents-registry/src/test/java/io/quarkiverse/dapr/agents/registry/model/AgentMetadataSchemaTest.java new file mode 100644 index 000000000..6c58349a1 --- /dev/null +++ b/quarkus/quarkus-agentic-dapr-agents-registry/src/test/java/io/quarkiverse/dapr/agents/registry/model/AgentMetadataSchemaTest.java @@ -0,0 +1,404 @@ +package io.quarkiverse.dapr.agents.registry.model; + +import java.util.List; +import java.util.Map; + +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +class AgentMetadataSchemaTest { + + private final ObjectMapper mapper = new ObjectMapper(); + + @Test + void buildMinimalSchema() { + AgentMetadataSchema schema = AgentMetadataSchema.builder() + .schemaVersion("0.11.1") + .name("test-agent") + .registeredAt("2025-01-01T00:00:00Z") + .agent(AgentMetadata.builder() + .appId("my-app") + .type("standalone") + .build()) + .build(); + + assertThat(schema.getSchemaVersion()).isEqualTo("0.11.1"); + assertThat(schema.getName()).isEqualTo("test-agent"); + assertThat(schema.getRegisteredAt()).isEqualTo("2025-01-01T00:00:00Z"); + assertThat(schema.getAgent().getAppId()).isEqualTo("my-app"); + assertThat(schema.getAgent().getType()).isEqualTo("standalone"); + assertThat(schema.getAgent().isOrchestrator()).isFalse(); + assertThat(schema.getAgent().getRole()).isEmpty(); + assertThat(schema.getAgent().getGoal()).isEmpty(); + assertThat(schema.getPubsub()).isNull(); + assertThat(schema.getMemory()).isNull(); + assertThat(schema.getLlm()).isNull(); + assertThat(schema.getRegistry()).isNull(); + assertThat(schema.getTools()).isNull(); + assertThat(schema.getMaxIterations()).isNull(); + assertThat(schema.getToolChoice()).isNull(); + assertThat(schema.getAgentMetadata()).isNull(); + } + + @Test + void buildFullSchema() { + AgentMetadataSchema schema = AgentMetadataSchema.builder() + .schemaVersion("0.11.1") + .name("orchestrator-agent") + .registeredAt("2025-06-15T10:30:00Z") + .agent(AgentMetadata.builder() + .appId("orch-app") + .type("durable") + .orchestrator(true) + .role("coordinator") + .goal("Coordinate tasks across agents") + .instructions(List.of("Be concise", "Delegate work")) + .statestore("statestore") + .systemPrompt("You are a coordinator agent.") + .framework("langchain4j") + .build()) + .pubsub(PubSubMetadata.builder() + .name("pubsub") + .broadcastTopic("broadcast") + .agentTopic("agent-messages") + .build()) + .memory(MemoryMetadata.builder() + .type("conversation") + .statestore("memory-store") + .build()) + .llm(LlmMetadata.builder() + .client("openai") + .provider("openai") + .api("chat") + .model("gpt-4") + .baseUrl("https://api.openai.com") + .promptTemplate("Answer: {input}") + .build()) + .registry(RegistryMetadata.builder() + .statestore("registry-store") + .name("team-registry") + .build()) + .addTool(ToolMetadata.builder() + .toolName("search") + .toolDescription("Search the web") + .toolArgs("{\"query\": \"string\"}") + .build()) + .addTool(ToolMetadata.builder() + .toolName("calculator") + .toolDescription("Perform calculations") + .toolArgs("{\"expression\": \"string\"}") + .build()) + .maxIterations(10) + .toolChoice("auto") + .agentMetadata(Map.of("version", "1.0", "team", "alpha")) + .build(); + + assertThat(schema.getAgent().isOrchestrator()).isTrue(); + assertThat(schema.getAgent().getRole()).isEqualTo("coordinator"); + assertThat(schema.getAgent().getGoal()).isEqualTo("Coordinate tasks across agents"); + assertThat(schema.getAgent().getInstructions()).containsExactly("Be concise", "Delegate work"); + assertThat(schema.getAgent().getStatestore()).isEqualTo("statestore"); + assertThat(schema.getAgent().getSystemPrompt()).isEqualTo("You are a coordinator agent."); + assertThat(schema.getAgent().getFramework()).isEqualTo("langchain4j"); + assertThat(schema.getPubsub().getName()).isEqualTo("pubsub"); + assertThat(schema.getPubsub().getBroadcastTopic()).isEqualTo("broadcast"); + assertThat(schema.getPubsub().getAgentTopic()).isEqualTo("agent-messages"); + assertThat(schema.getMemory().getType()).isEqualTo("conversation"); + assertThat(schema.getMemory().getStatestore()).isEqualTo("memory-store"); + assertThat(schema.getLlm().getClient()).isEqualTo("openai"); + assertThat(schema.getLlm().getProvider()).isEqualTo("openai"); + assertThat(schema.getLlm().getApi()).isEqualTo("chat"); + assertThat(schema.getLlm().getModel()).isEqualTo("gpt-4"); + assertThat(schema.getLlm().getBaseUrl()).isEqualTo("https://api.openai.com"); + assertThat(schema.getLlm().getPromptTemplate()).isEqualTo("Answer: {input}"); + assertThat(schema.getRegistry().getStatestore()).isEqualTo("registry-store"); + assertThat(schema.getRegistry().getName()).isEqualTo("team-registry"); + assertThat(schema.getTools()).hasSize(2); + assertThat(schema.getTools().get(0).getToolName()).isEqualTo("search"); + assertThat(schema.getTools().get(1).getToolName()).isEqualTo("calculator"); + assertThat(schema.getMaxIterations()).isEqualTo(10); + assertThat(schema.getToolChoice()).isEqualTo("auto"); + assertThat(schema.getAgentMetadata()).containsEntry("version", "1.0"); + } + + @Test + void buildLlmWithAzureConfig() { + LlmMetadata llm = LlmMetadata.builder() + .client("azure-openai") + .provider("azure") + .azureEndpoint("https://my-resource.openai.azure.com") + .azureDeployment("gpt-4-deployment") + .componentName("llm-component") + .build(); + + assertThat(llm.getAzureEndpoint()).isEqualTo("https://my-resource.openai.azure.com"); + assertThat(llm.getAzureDeployment()).isEqualTo("gpt-4-deployment"); + assertThat(llm.getComponentName()).isEqualTo("llm-component"); + assertThat(llm.getApi()).isEqualTo("unknown"); + assertThat(llm.getModel()).isEqualTo("unknown"); + } + + @Test + void buildLlmWithDefaults() { + LlmMetadata llm = LlmMetadata.builder() + .client("openai") + .provider("openai") + .build(); + + assertThat(llm.getApi()).isEqualTo("unknown"); + assertThat(llm.getModel()).isEqualTo("unknown"); + assertThat(llm.getComponentName()).isNull(); + assertThat(llm.getBaseUrl()).isNull(); + } + + @Test + void schemaBuilderRequiresAllRequiredFields() { + assertThatThrownBy(() -> AgentMetadataSchema.builder().build()) + .isInstanceOf(IllegalStateException.class) + .hasMessageContaining("schemaVersion, agent, name, and registeredAt are required"); + } + + @Test + void agentBuilderRequiresAppIdAndType() { + assertThatThrownBy(() -> AgentMetadata.builder().build()) + .isInstanceOf(IllegalStateException.class) + .hasMessageContaining("appId and type are required"); + } + + @Test + void llmBuilderRequiresClientAndProvider() { + assertThatThrownBy(() -> LlmMetadata.builder().build()) + .isInstanceOf(IllegalStateException.class) + .hasMessageContaining("client and provider are required"); + } + + @Test + void memoryBuilderRequiresType() { + assertThatThrownBy(() -> MemoryMetadata.builder().build()) + .isInstanceOf(IllegalStateException.class) + .hasMessageContaining("type is required"); + } + + @Test + void pubsubBuilderRequiresName() { + assertThatThrownBy(() -> PubSubMetadata.builder().build()) + .isInstanceOf(IllegalStateException.class) + .hasMessageContaining("name is required"); + } + + @Test + void toolBuilderRequiresAllFields() { + assertThatThrownBy(() -> ToolMetadata.builder().build()) + .isInstanceOf(IllegalStateException.class) + .hasMessageContaining("toolName, toolDescription, and toolArgs are required"); + } + + @Test + void registryBuilderHasNoRequiredFields() { + RegistryMetadata registry = RegistryMetadata.builder().build(); + assertThat(registry.getStatestore()).isNull(); + assertThat(registry.getName()).isNull(); + } + + @Test + void serializeMinimalSchemaToJson() throws Exception { + AgentMetadataSchema schema = AgentMetadataSchema.builder() + .schemaVersion("0.11.1") + .name("test-agent") + .registeredAt("2025-01-01T00:00:00Z") + .agent(AgentMetadata.builder() + .appId("my-app") + .type("standalone") + .build()) + .build(); + + String json = mapper.writeValueAsString(schema); + + assertThat(json).contains("\"schema_version\":\"0.11.1\""); + assertThat(json).contains("\"name\":\"test-agent\""); + assertThat(json).contains("\"registered_at\":\"2025-01-01T00:00:00Z\""); + assertThat(json).contains("\"appid\":\"my-app\""); + assertThat(json).contains("\"type\":\"standalone\""); + // null fields should be excluded + assertThat(json).doesNotContain("\"pubsub\""); + assertThat(json).doesNotContain("\"memory\""); + assertThat(json).doesNotContain("\"llm\""); + assertThat(json).doesNotContain("\"registry\""); + assertThat(json).doesNotContain("\"tools\""); + assertThat(json).doesNotContain("\"max_iterations\""); + assertThat(json).doesNotContain("\"tool_choice\""); + assertThat(json).doesNotContain("\"agent_metadata\""); + } + + @Test + void serializeAndDeserializeFullSchema() throws Exception { + AgentMetadataSchema original = AgentMetadataSchema.builder() + .schemaVersion("0.11.1") + .name("round-trip-agent") + .registeredAt("2025-06-15T10:30:00Z") + .agent(AgentMetadata.builder() + .appId("rt-app") + .type("durable") + .orchestrator(true) + .role("planner") + .goal("Plan tasks") + .instructions(List.of("Step 1", "Step 2")) + .statestore("state-store") + .systemPrompt("You are a planner.") + .framework("quarkus") + .build()) + .pubsub(PubSubMetadata.builder() + .name("pubsub") + .broadcastTopic("broadcast") + .agentTopic("agent-topic") + .build()) + .memory(MemoryMetadata.builder() + .type("buffer") + .statestore("mem-store") + .build()) + .llm(LlmMetadata.builder() + .client("openai") + .provider("openai") + .api("chat") + .model("gpt-4o") + .baseUrl("https://api.openai.com") + .build()) + .registry(RegistryMetadata.builder() + .statestore("reg-store") + .name("my-registry") + .build()) + .addTool(ToolMetadata.builder() + .toolName("search") + .toolDescription("Web search") + .toolArgs("{}") + .build()) + .maxIterations(5) + .toolChoice("auto") + .agentMetadata(Map.of("env", "prod")) + .build(); + + String json = mapper.writeValueAsString(original); + AgentMetadataSchema deserialized = mapper.readValue(json, AgentMetadataSchema.class); + + assertThat(deserialized.getSchemaVersion()).isEqualTo("0.11.1"); + assertThat(deserialized.getName()).isEqualTo("round-trip-agent"); + assertThat(deserialized.getRegisteredAt()).isEqualTo("2025-06-15T10:30:00Z"); + assertThat(deserialized.getAgent().getAppId()).isEqualTo("rt-app"); + assertThat(deserialized.getAgent().getType()).isEqualTo("durable"); + assertThat(deserialized.getAgent().isOrchestrator()).isTrue(); + assertThat(deserialized.getAgent().getRole()).isEqualTo("planner"); + assertThat(deserialized.getAgent().getGoal()).isEqualTo("Plan tasks"); + assertThat(deserialized.getAgent().getInstructions()).containsExactly("Step 1", "Step 2"); + assertThat(deserialized.getAgent().getStatestore()).isEqualTo("state-store"); + assertThat(deserialized.getAgent().getSystemPrompt()).isEqualTo("You are a planner."); + assertThat(deserialized.getAgent().getFramework()).isEqualTo("quarkus"); + assertThat(deserialized.getPubsub().getName()).isEqualTo("pubsub"); + assertThat(deserialized.getPubsub().getBroadcastTopic()).isEqualTo("broadcast"); + assertThat(deserialized.getPubsub().getAgentTopic()).isEqualTo("agent-topic"); + assertThat(deserialized.getMemory().getType()).isEqualTo("buffer"); + assertThat(deserialized.getMemory().getStatestore()).isEqualTo("mem-store"); + assertThat(deserialized.getLlm().getClient()).isEqualTo("openai"); + assertThat(deserialized.getLlm().getModel()).isEqualTo("gpt-4o"); + assertThat(deserialized.getLlm().getBaseUrl()).isEqualTo("https://api.openai.com"); + assertThat(deserialized.getRegistry().getStatestore()).isEqualTo("reg-store"); + assertThat(deserialized.getRegistry().getName()).isEqualTo("my-registry"); + assertThat(deserialized.getTools()).hasSize(1); + assertThat(deserialized.getTools().get(0).getToolName()).isEqualTo("search"); + assertThat(deserialized.getMaxIterations()).isEqualTo(5); + assertThat(deserialized.getToolChoice()).isEqualTo("auto"); + assertThat(deserialized.getAgentMetadata()).containsEntry("env", "prod"); + } + + @Test + void deserializeFromJson() throws Exception { + String json = """ + { + "schema_version": "0.11.1", + "name": "json-agent", + "registered_at": "2025-03-01T00:00:00Z", + "agent": { + "appid": "json-app", + "type": "standalone", + "orchestrator": false, + "role": "worker", + "goal": "Process tasks", + "instructions": ["Follow orders"], + "system_prompt": "You are a worker.", + "framework": "dapr" + }, + "llm": { + "client": "anthropic", + "provider": "anthropic", + "model": "claude-3" + }, + "tools": [ + { + "tool_name": "fetch", + "tool_description": "Fetch URL", + "tool_args": "{\\"url\\": \\"string\\"}" + } + ], + "max_iterations": 20, + "tool_choice": "required" + } + """; + + AgentMetadataSchema schema = mapper.readValue(json, AgentMetadataSchema.class); + + assertThat(schema.getSchemaVersion()).isEqualTo("0.11.1"); + assertThat(schema.getName()).isEqualTo("json-agent"); + assertThat(schema.getAgent().getAppId()).isEqualTo("json-app"); + assertThat(schema.getAgent().getType()).isEqualTo("standalone"); + assertThat(schema.getAgent().isOrchestrator()).isFalse(); + assertThat(schema.getAgent().getRole()).isEqualTo("worker"); + assertThat(schema.getAgent().getGoal()).isEqualTo("Process tasks"); + assertThat(schema.getAgent().getInstructions()).containsExactly("Follow orders"); + assertThat(schema.getAgent().getSystemPrompt()).isEqualTo("You are a worker."); + assertThat(schema.getAgent().getFramework()).isEqualTo("dapr"); + assertThat(schema.getLlm().getClient()).isEqualTo("anthropic"); + assertThat(schema.getLlm().getProvider()).isEqualTo("anthropic"); + assertThat(schema.getLlm().getModel()).isEqualTo("claude-3"); + assertThat(schema.getTools()).hasSize(1); + assertThat(schema.getTools().get(0).getToolName()).isEqualTo("fetch"); + assertThat(schema.getMaxIterations()).isEqualTo(20); + assertThat(schema.getToolChoice()).isEqualTo("required"); + assertThat(schema.getPubsub()).isNull(); + assertThat(schema.getMemory()).isNull(); + assertThat(schema.getRegistry()).isNull(); + } + + @Test + void addToolIncrementally() { + AgentMetadataSchema schema = AgentMetadataSchema.builder() + .schemaVersion("0.11.1") + .name("tool-agent") + .registeredAt("2025-01-01T00:00:00Z") + .agent(AgentMetadata.builder() + .appId("tool-app") + .type("standalone") + .build()) + .addTool(ToolMetadata.builder() + .toolName("t1") + .toolDescription("First tool") + .toolArgs("{}") + .build()) + .addTool(ToolMetadata.builder() + .toolName("t2") + .toolDescription("Second tool") + .toolArgs("{}") + .build()) + .addTool(ToolMetadata.builder() + .toolName("t3") + .toolDescription("Third tool") + .toolArgs("{}") + .build()) + .build(); + + assertThat(schema.getTools()).hasSize(3); + assertThat(schema.getTools()).extracting(ToolMetadata::getToolName) + .containsExactly("t1", "t2", "t3"); + } +} \ No newline at end of file diff --git a/quarkus/quarkus-agentic-dapr-agents-registry/src/test/java/io/quarkiverse/dapr/agents/registry/service/AgentRegistryDevServicesTest.java b/quarkus/quarkus-agentic-dapr-agents-registry/src/test/java/io/quarkiverse/dapr/agents/registry/service/AgentRegistryDevServicesTest.java new file mode 100644 index 000000000..7a155c65b --- /dev/null +++ b/quarkus/quarkus-agentic-dapr-agents-registry/src/test/java/io/quarkiverse/dapr/agents/registry/service/AgentRegistryDevServicesTest.java @@ -0,0 +1,120 @@ +package io.quarkiverse.dapr.agents.registry.service; + +import io.dapr.client.DaprClient; +import io.dapr.client.domain.State; +import io.quarkiverse.dapr.agents.registry.model.AgentMetadataSchema; +import io.quarkus.test.junit.QuarkusTest; +import jakarta.inject.Inject; +import org.junit.jupiter.api.Test; + +import java.time.Duration; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.awaitility.Awaitility.await; + +/** + * Integration tests for {@link AgentRegistry} using Dapr dev services. + *

+ * Requires Docker for Dapr dev services (starts daprd, placement, scheduler, + * PostgreSQL state store, and dashboard containers via Testcontainers). + * Uses {@link MockChatModel} instead of a real LLM. + * Uses {@link TestAgentBean} to provide a CDI bean with {@code @Agent}-annotated + * interface methods for the registry to discover. + */ +@QuarkusTest +class AgentRegistryDevServicesTest { + + private static final String STATE_STORE = "kvstore"; + private static final String TEAM = "test-team"; + private static final String APP_ID = "local-dapr-app"; + + @Inject + AgentRegistry registry; + + @Inject + DaprClient daprClient; + + @Test + void registryShouldBeInjectable() { + assertThat(registry).isNotNull(); + } + + @Test + void daprClientShouldBeInjectable() { + assertThat(daprClient).isNotNull(); + } + + @Test + void autoDiscoveredAgentWithPromptShouldBeInStateStore() { + await().atMost(Duration.ofSeconds(30)).untilAsserted(() -> { + State state = daprClient.getState( + STATE_STORE, "agents:" + TEAM + ":test-agent-with-prompt", AgentMetadataSchema.class).block(); + assertThat(state).isNotNull(); + assertThat(state.getValue()).isNotNull(); + + AgentMetadataSchema schema = state.getValue(); + assertThat(schema.getSchemaVersion()).isEqualTo("0.11.1"); + assertThat(schema.getName()).isEqualTo("test-agent-with-prompt"); + assertThat(schema.getAgent().getAppId()).isEqualTo(APP_ID); + assertThat(schema.getAgent().getType()).isEqualTo("standalone"); + assertThat(schema.getAgent().getGoal()).isEqualTo("Agent with system prompt"); + assertThat(schema.getAgent().getFramework()).isEqualTo("langchain4j"); + assertThat(schema.getAgent().getSystemPrompt()).isEqualTo("You are a test agent for integration testing."); + assertThat(schema.getRegisteredAt()).isNotBlank(); + }); + } + + @Test + void autoDiscoveredSimpleAgentShouldBeInStateStore() { + await().atMost(Duration.ofSeconds(30)).untilAsserted(() -> { + State state = daprClient.getState( + STATE_STORE, "agents:" + TEAM + ":test-agent-simple", AgentMetadataSchema.class).block(); + assertThat(state).isNotNull(); + assertThat(state.getValue()).isNotNull(); + + AgentMetadataSchema schema = state.getValue(); + assertThat(schema.getName()).isEqualTo("test-agent-simple"); + assertThat(schema.getAgent().getGoal()).isEqualTo("Simple agent without prompt"); + assertThat(schema.getAgent().getSystemPrompt()).isNull(); + assertThat(schema.getAgent().getFramework()).isEqualTo("langchain4j"); + }); + } + + @Test + void agentWithDefaultNameShouldUseInterfaceAndMethodName() { + await().atMost(Duration.ofSeconds(30)).untilAsserted(() -> { + State state = daprClient.getState( + STATE_STORE, "agents:" + TEAM + ":TestAgent.defaultNameAgent", AgentMetadataSchema.class).block(); + assertThat(state).isNotNull(); + assertThat(state.getValue()).isNotNull(); + + AgentMetadataSchema schema = state.getValue(); + assertThat(schema.getName()).isEqualTo("TestAgent.defaultNameAgent"); + assertThat(schema.getAgent().getGoal()).isEqualTo("Agent with default name"); + }); + } + + + + @Test + void allAutoDiscoveredAgentsShouldHaveConsistentMetadata() { + String[] expectedAgents = {"test-agent-with-prompt", "test-agent-simple", "TestAgent.defaultNameAgent"}; + + await().atMost(Duration.ofSeconds(30)).untilAsserted(() -> { + for (String agentName : expectedAgents) { + State state = daprClient.getState( + STATE_STORE, "agents:" + TEAM + ":" + agentName, AgentMetadataSchema.class).block(); + assertThat(state.getValue()) + .as("Agent '%s' should be registered", agentName) + .isNotNull(); + + AgentMetadataSchema schema = state.getValue(); + assertThat(schema.getSchemaVersion()).isEqualTo("0.11.1"); + assertThat(schema.getAgent().getAppId()).isEqualTo(APP_ID); + assertThat(schema.getAgent().getType()).isEqualTo("standalone"); + assertThat(schema.getAgent().getFramework()).isEqualTo("langchain4j"); + assertThat(schema.getRegisteredAt()).isNotBlank(); + } + }); + } +} diff --git a/quarkus/quarkus-agentic-dapr-agents-registry/src/test/java/io/quarkiverse/dapr/agents/registry/service/AgentRegistryTest.java b/quarkus/quarkus-agentic-dapr-agents-registry/src/test/java/io/quarkiverse/dapr/agents/registry/service/AgentRegistryTest.java new file mode 100644 index 000000000..306d23f26 --- /dev/null +++ b/quarkus/quarkus-agentic-dapr-agents-registry/src/test/java/io/quarkiverse/dapr/agents/registry/service/AgentRegistryTest.java @@ -0,0 +1,190 @@ +package io.quarkiverse.dapr.agents.registry.service; + +import dev.langchain4j.agentic.Agent; +import dev.langchain4j.service.SystemMessage; +import io.quarkiverse.dapr.agents.registry.model.AgentMetadataSchema; +import org.junit.jupiter.api.Test; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; + +class AgentRegistryTest { + + private static final String APP_ID = "test-app"; + + // --- Test interfaces --- + // Note: @Agent methods use no parameters to avoid validation errors from + // the langchain4j AgenticProcessor deployment step during @QuarkusTest runs. + + interface SimpleAgent { + @Agent(name = "my-agent", description = "A simple agent") + String chat(); + } + + interface AgentWithPrompts { + @Agent(name = "prompted-agent", description = "Agent with prompts") + @SystemMessage("You are a helpful assistant.") + String ask(); + } + + interface AgentWithDefaultName { + @Agent(description = "Agent with no explicit name") + String doWork(); + } + + interface NoAgentInterface { + String regularMethod(); + } + + interface MultipleAgentMethods { + @Agent(name = "agent-one", description = "First agent") + String first(); + + @Agent(name = "agent-two", description = "Second agent") + @SystemMessage("You are agent two.") + String second(); + } + + // --- Test annotation and interfaces for sub-agent discovery --- + + @Retention(RetentionPolicy.RUNTIME) + @Target(ElementType.METHOD) + @interface MockSequenceAgent { + Class[] subAgents(); + } + + interface SubAgentA { + @Agent(name = "sub-agent-a", description = "Sub-agent A") + String run(); + } + + interface SubAgentB { + @Agent(name = "sub-agent-b", description = "Sub-agent B") + String run(); + } + + interface CompositeAgent { + @MockSequenceAgent(subAgents = { SubAgentA.class, SubAgentB.class }) + String orchestrate(); + } + + // --- Tests --- + + @Test + void simpleAgentDiscovery() { + List agents = AgentRegistry.scanForAgents(SimpleAgent.class, APP_ID); + + assertThat(agents).hasSize(1); + AgentMetadataSchema schema = agents.get(0); + assertThat(schema.getSchemaVersion()).isEqualTo("0.11.1"); + assertThat(schema.getName()).isEqualTo("my-agent"); + assertThat(schema.getAgent().getGoal()).isEqualTo("A simple agent"); + assertThat(schema.getAgent().getAppId()).isEqualTo(APP_ID); + assertThat(schema.getAgent().getType()).isEqualTo("standalone"); + assertThat(schema.getAgent().getFramework()).isEqualTo("langchain4j"); + assertThat(schema.getAgent().getSystemPrompt()).isNull(); + assertThat(schema.getRegisteredAt()).isNotBlank(); + } + + @Test + void agentWithPromptsExtractsSystemMessage() { + List agents = AgentRegistry.scanForAgents(AgentWithPrompts.class, APP_ID); + + assertThat(agents).hasSize(1); + AgentMetadataSchema schema = agents.get(0); + assertThat(schema.getName()).isEqualTo("prompted-agent"); + assertThat(schema.getAgent().getGoal()).isEqualTo("Agent with prompts"); + assertThat(schema.getAgent().getSystemPrompt()).isEqualTo("You are a helpful assistant."); + assertThat(schema.getAgent().getFramework()).isEqualTo("langchain4j"); + } + + @Test + void agentWithDefaultNameFallsBackToClassAndMethod() { + List agents = AgentRegistry.scanForAgents(AgentWithDefaultName.class, APP_ID); + + assertThat(agents).hasSize(1); + AgentMetadataSchema schema = agents.get(0); + assertThat(schema.getName()).isEqualTo("AgentWithDefaultName.doWork"); + assertThat(schema.getAgent().getGoal()).isEqualTo("Agent with no explicit name"); + } + + @Test + void noAgentInterfaceReturnsEmptyList() { + List agents = AgentRegistry.scanForAgents(NoAgentInterface.class, APP_ID); + + assertThat(agents).isEmpty(); + } + + @Test + void multipleAgentMethodsDiscoveredSeparately() { + List agents = AgentRegistry.scanForAgents(MultipleAgentMethods.class, APP_ID); + + assertThat(agents).hasSize(2); + assertThat(agents).extracting(AgentMetadataSchema::getName) + .containsExactlyInAnyOrder("agent-one", "agent-two"); + + AgentMetadataSchema agentTwo = agents.stream() + .filter(a -> "agent-two".equals(a.getName())) + .findFirst().orElseThrow(); + assertThat(agentTwo.getAgent().getSystemPrompt()).isEqualTo("You are agent two."); + assertThat(agentTwo.getAgent().getGoal()).isEqualTo("Second agent"); + + AgentMetadataSchema agentOne = agents.stream() + .filter(a -> "agent-one".equals(a.getName())) + .findFirst().orElseThrow(); + assertThat(agentOne.getAgent().getSystemPrompt()).isNull(); + assertThat(agentOne.getAgent().getGoal()).isEqualTo("First agent"); + } + + @Test + void allSchemasHaveCorrectVersionAndAppId() { + List agents = AgentRegistry.scanForAgents(MultipleAgentMethods.class, APP_ID); + + for (AgentMetadataSchema schema : agents) { + assertThat(schema.getSchemaVersion()).isEqualTo("0.11.1"); + assertThat(schema.getAgent().getAppId()).isEqualTo(APP_ID); + assertThat(schema.getAgent().getFramework()).isEqualTo("langchain4j"); + assertThat(schema.getAgent().getType()).isEqualTo("standalone"); + } + } + + @Test + void extractSubAgentClassesFromCompositeAnnotation() throws Exception { + java.lang.annotation.Annotation ann = CompositeAgent.class + .getDeclaredMethod("orchestrate") + .getDeclaredAnnotations()[0]; // @MockSequenceAgent + + Class[] subAgents = AgentRegistry.extractSubAgentClasses(ann); + + assertThat(subAgents).containsExactly(SubAgentA.class, SubAgentB.class); + } + + @Test + void extractSubAgentClassesReturnsEmptyForNonComposite() throws Exception { + java.lang.annotation.Annotation ann = SimpleAgent.class + .getDeclaredMethod("chat") + .getDeclaredAnnotations()[0]; // @Agent + + Class[] subAgents = AgentRegistry.extractSubAgentClasses(ann); + + assertThat(subAgents).isEmpty(); + } + + @Test + void scanForAgentsDiscoverSubAgentInterfaces() { + // SubAgentA and SubAgentB are not CDI beans, but their @Agent should be scannable + List agentsA = AgentRegistry.scanForAgents(SubAgentA.class, APP_ID); + List agentsB = AgentRegistry.scanForAgents(SubAgentB.class, APP_ID); + + assertThat(agentsA).hasSize(1); + assertThat(agentsA.get(0).getName()).isEqualTo("sub-agent-a"); + + assertThat(agentsB).hasSize(1); + assertThat(agentsB.get(0).getName()).isEqualTo("sub-agent-b"); + } +} diff --git a/quarkus/quarkus-agentic-dapr-agents-registry/src/test/java/io/quarkiverse/dapr/agents/registry/service/MockChatModel.java b/quarkus/quarkus-agentic-dapr-agents-registry/src/test/java/io/quarkiverse/dapr/agents/registry/service/MockChatModel.java new file mode 100644 index 000000000..56d5865fb --- /dev/null +++ b/quarkus/quarkus-agentic-dapr-agents-registry/src/test/java/io/quarkiverse/dapr/agents/registry/service/MockChatModel.java @@ -0,0 +1,30 @@ +package io.quarkiverse.dapr.agents.registry.service; + +import dev.langchain4j.data.message.AiMessage; +import dev.langchain4j.model.chat.ChatModel; +import dev.langchain4j.model.chat.request.ChatRequest; +import dev.langchain4j.model.chat.response.ChatResponse; +import dev.langchain4j.model.output.FinishReason; +import dev.langchain4j.model.output.TokenUsage; +import jakarta.annotation.Priority; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.enterprise.inject.Alternative; + +/** + * Mock ChatModel that returns predictable responses for integration testing. + * Takes priority over the OpenAI ChatModel bean via {@code @Alternative @Priority(1)}. + */ +@Alternative +@Priority(1) +@ApplicationScoped +public class MockChatModel implements ChatModel { + + @Override + public ChatResponse doChat(ChatRequest request) { + return ChatResponse.builder() + .aiMessage(AiMessage.from("Mock response for testing.")) + .tokenUsage(new TokenUsage(5, 10)) + .finishReason(FinishReason.STOP) + .build(); + } +} diff --git a/quarkus/quarkus-agentic-dapr-agents-registry/src/test/java/io/quarkiverse/dapr/agents/registry/service/TestAgent.java b/quarkus/quarkus-agentic-dapr-agents-registry/src/test/java/io/quarkiverse/dapr/agents/registry/service/TestAgent.java new file mode 100644 index 000000000..e61666bff --- /dev/null +++ b/quarkus/quarkus-agentic-dapr-agents-registry/src/test/java/io/quarkiverse/dapr/agents/registry/service/TestAgent.java @@ -0,0 +1,24 @@ +package io.quarkiverse.dapr.agents.registry.service; + +import dev.langchain4j.agentic.Agent; +import dev.langchain4j.service.SystemMessage; + +/** + * Test agent interface for verifying auto-discovery by {@link AgentRegistry}. + * Contains multiple {@code @Agent} methods covering different metadata combinations. + *

+ * Methods have no parameters to avoid validation errors from the langchain4j + * AgenticProcessor which expects parameters to resolve from agent output keys. + */ +public interface TestAgent { + + @Agent(name = "test-agent-with-prompt", description = "Agent with system prompt") + @SystemMessage("You are a test agent for integration testing.") + String chatWithPrompt(); + + @Agent(name = "test-agent-simple", description = "Simple agent without prompt") + String chatSimple(); + + @Agent(description = "Agent with default name") + String defaultNameAgent(); +} diff --git a/quarkus/quarkus-agentic-dapr-agents-registry/src/test/java/io/quarkiverse/dapr/agents/registry/service/TestAgentBean.java b/quarkus/quarkus-agentic-dapr-agents-registry/src/test/java/io/quarkiverse/dapr/agents/registry/service/TestAgentBean.java new file mode 100644 index 000000000..7edb7721b --- /dev/null +++ b/quarkus/quarkus-agentic-dapr-agents-registry/src/test/java/io/quarkiverse/dapr/agents/registry/service/TestAgentBean.java @@ -0,0 +1,30 @@ +package io.quarkiverse.dapr.agents.registry.service; + +import jakarta.annotation.Priority; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.enterprise.inject.Alternative; + +/** + * CDI bean implementing {@link TestAgent} so that {@link AgentRegistry} + * can discover it via {@code BeanManager} during startup. + */ +@Alternative +@Priority(1) +@ApplicationScoped +public class TestAgentBean implements TestAgent { + + @Override + public String chatWithPrompt() { + return "mock response"; + } + + @Override + public String chatSimple() { + return "mock response"; + } + + @Override + public String defaultNameAgent() { + return "mock response"; + } +} diff --git a/quarkus/quarkus-agentic-dapr-agents-registry/src/test/resources/application.properties b/quarkus/quarkus-agentic-dapr-agents-registry/src/test/resources/application.properties new file mode 100644 index 000000000..c9b76a36a --- /dev/null +++ b/quarkus/quarkus-agentic-dapr-agents-registry/src/test/resources/application.properties @@ -0,0 +1,13 @@ +# Dapr Dev Services with PostgreSQL state store (dashboard enabled = uses PostgreSQL) +quarkus.dapr.devservices.enabled=true +quarkus.dapr.devservices.dashboard.enabled=true + +# Agent registry configuration +# Dev services name the state store component "kvstore" +dapr.agents.statestore=kvstore +dapr.appid=local-dapr-app +dapr.agents.team=test-team + +# Dummy OpenAI key (MockChatModel overrides the real provider in tests) +quarkus.langchain4j.openai.api-key=test-key +quarkus.langchain4j.openai.chat-model.model-name=gpt-4o-mini diff --git a/quarkus/runtime/pom.xml b/quarkus/runtime/pom.xml new file mode 100644 index 000000000..d58450e0d --- /dev/null +++ b/quarkus/runtime/pom.xml @@ -0,0 +1,88 @@ + + + 4.0.0 + + io.dapr.quarkus + dapr-quarkus-agentic-parent + 1.18.0-SNAPSHOT + ../pom.xml + + + quarkus-agentic-dapr + Dapr Quarkus Agentic - Runtime + + + + io.quarkiverse.dapr + quarkus-dapr + ${quarkus-dapr.version} + + + io.dapr + dapr-sdk-workflows + + + io.quarkiverse.langchain4j + quarkus-langchain4j-agentic + ${quarkus-langchain4j.version} + + + io.quarkus + quarkus-arc + + + org.junit.jupiter + junit-jupiter + test + + + org.mockito + mockito-core + 5.14.2 + test + + + org.assertj + assertj-core + 3.26.3 + test + + + + + + + io.quarkus + quarkus-extension-maven-plugin + ${quarkus.version} + + + compile + + extension-descriptor + + + ${project.groupId}:${project.artifactId}-deployment:${project.version} + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.13.0 + + + + io.quarkus + quarkus-extension-processor + ${quarkus.version} + + + + + + + diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/AgentRunContext.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/AgentRunContext.java new file mode 100644 index 000000000..f69296be7 --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/AgentRunContext.java @@ -0,0 +1,146 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.agent; + +import java.lang.reflect.Method; +import java.util.Arrays; +import java.util.Map; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ConcurrentHashMap; + +/** + * Holds the synchronization state for a single agent execution. + * + *

When a {@code @Tool}-annotated method is intercepted by {@link DaprToolCallInterceptor}, + * it registers a {@link PendingCall} here and blocks until + * {@link io.quarkiverse.dapr.langchain4j.agent.activities.ToolCallActivity} executes the + * tool on the Dapr Workflow Activity thread and completes the future. + */ +public class AgentRunContext { + + /** + * Holds all the information needed for {@code ToolCallActivity} to execute the tool + * and unblock the waiting agent thread. + */ + @SuppressWarnings("EI_EXPOSE_REP") + public record PendingCall( + Object target, + Method method, + Object[] args, + CompletableFuture resultFuture) { + + /** + * Creates a PendingCall with a defensive copy of args. + * + * @param target the object instance on which the method will be invoked + * @param method the reflective method handle + * @param args the arguments to pass to the method + * @param resultFuture future to complete when the call finishes + */ + public PendingCall(Object target, Method method, Object[] args, + CompletableFuture resultFuture) { + this.target = target; + this.method = method; + this.args = args == null ? null : Arrays.copyOf(args, args.length); + this.resultFuture = resultFuture; + } + + /** + * Returns a defensive copy of args. + * + * @return copy of args array + */ + @Override + public Object[] args() { + return args == null ? null : Arrays.copyOf(args, args.length); + } + } + + private final String agentRunId; + private final Map pendingCalls = new ConcurrentHashMap<>(); + + /** + * Creates a new AgentRunContext for the given agent run ID. + * + * @param agentRunId the unique identifier for the agent run + */ + public AgentRunContext(String agentRunId) { + this.agentRunId = agentRunId; + } + + /** + * Returns the agent run ID associated with this context. + * + * @return the agent run ID + */ + public String getAgentRunId() { + return agentRunId; + } + + /** + * Register a pending tool call and return the future that will be completed by + * {@code ToolCallActivity} once the tool has executed. + * + * @param toolCallId the unique identifier for this tool call + * @param target the object instance on which the tool method will be invoked + * @param method the reflective method handle for the tool + * @param args the arguments to pass to the tool method + * @return a future that completes with the tool execution result + */ + public CompletableFuture registerCall( + String toolCallId, Object target, Method method, Object[] args) { + CompletableFuture future = new CompletableFuture<>(); + pendingCalls.put(toolCallId, new PendingCall(target, method, args, future)); + return future; + } + + /** + * Returns the pending call for the given tool call ID without removing it. + * Used by {@code ToolCallActivity} to retrieve call details. + * + * @param toolCallId the unique identifier for the tool call to look up + * @return the pending call, or {@code null} if no call exists for the given ID + */ + public PendingCall getPendingCall(String toolCallId) { + return pendingCalls.get(toolCallId); + } + + /** + * Complete the pending call with a successful result. Removes the entry and + * unblocks the agent thread waiting in {@link DaprToolCallInterceptor}. + * + * @param toolCallId the unique identifier for the tool call to complete + * @param result the result value to deliver to the waiting thread + */ + public void completeCall(String toolCallId, Object result) { + PendingCall call = pendingCalls.remove(toolCallId); + if (call != null) { + call.resultFuture().complete(result); + } + } + + /** + * Complete the pending call with an exception. Removes the entry and + * propagates the failure to the waiting agent thread. + * + * @param toolCallId the unique identifier for the tool call to fail + * @param cause the exception to propagate to the waiting thread + */ + public void failCall(String toolCallId, Throwable cause) { + PendingCall call = pendingCalls.remove(toolCallId); + if (call != null) { + call.resultFuture().completeExceptionally(cause); + } + } +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/AgentRunLifecycleManager.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/AgentRunLifecycleManager.java new file mode 100644 index 000000000..5905dbc8a --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/AgentRunLifecycleManager.java @@ -0,0 +1,137 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.agent; + +import io.dapr.workflows.client.DaprWorkflowClient; +import io.quarkiverse.dapr.langchain4j.agent.workflow.AgentEvent; +import io.quarkiverse.dapr.langchain4j.agent.workflow.AgentRunInput; +import io.quarkiverse.dapr.langchain4j.agent.workflow.AgentRunWorkflow; +import io.quarkiverse.dapr.langchain4j.workflow.WorkflowNameResolver; +import jakarta.annotation.PreDestroy; +import jakarta.enterprise.context.RequestScoped; +import jakarta.inject.Inject; +import org.jboss.logging.Logger; + +import java.util.UUID; +/** + * Request-scoped CDI bean that manages the lifecycle of a lazily-started + * {@link AgentRunWorkflow} for standalone {@code @Agent} invocations. + * + *

Why this exists

+ * {@code @Agent} interfaces in quarkus-langchain4j are registered as synthetic beans + * (via {@code SyntheticBeanBuildItem}) without interception enabled. This means CDI interceptors + * such as {@code DaprAgentMethodInterceptor} cannot fire on {@code @Agent} method calls. + * + *

Instead, {@link DaprToolCallInterceptor} calls {@link #getOrActivate()} on the first + * {@code @Tool} method call it intercepts within a request that has no active Dapr agent context. + * This lazily starts the {@link AgentRunWorkflow} and sets {@link DaprAgentContextHolder} so + * that all subsequent tool calls within the same request are also routed through Dapr. + * + *

When the CDI request scope is destroyed (i.e., after the HTTP response is sent), + * {@link #cleanup()} sends the {@code "done"} event that terminates the {@link AgentRunWorkflow}. + */ + +@RequestScoped +public class AgentRunLifecycleManager { + + private static final Logger LOG = Logger.getLogger(AgentRunLifecycleManager.class); + + @Inject + DaprWorkflowClient workflowClient; + + private String agentRunId; + + /** + * Returns the active agent run ID for this request, lazily starting an + * {@link AgentRunWorkflow} if one has not been created yet. + * + *

This overload accepts the agent name and prompt metadata extracted from the + * {@code @Agent}, {@code @UserMessage}, and {@code @SystemMessage} annotations (CDI bean + * path) or from the rendered {@code ChatRequest} messages (AiService path). + * + * @param agentName the value of {@code @Agent(name)}, or {@code null} / blank to use + * {@code "standalone"} + * @param userMessage the user-message template or rendered text; may be {@code null} + * @param systemMessage the system-message template or rendered text; may be {@code null} + * @return the active agent run ID + */ + public String getOrActivate(String agentName, String userMessage, String systemMessage) { + if (agentRunId == null) { + agentRunId = UUID.randomUUID().toString(); + String name = (agentName != null && !agentName.isBlank()) ? agentName : "standalone"; + AgentRunContext runContext = new AgentRunContext(agentRunId); + DaprAgentRunRegistry.register(agentRunId, runContext); + workflowClient.scheduleNewWorkflow( + WorkflowNameResolver.resolve(AgentRunWorkflow.class), + new AgentRunInput(agentRunId, name, userMessage, systemMessage), agentRunId); + DaprAgentContextHolder.set(agentRunId); + LOG.infof("[AgentRun:%s] AgentRunWorkflow started (lazy — standalone @Agent), agent=%s", + agentRunId, name); + } + return agentRunId; + } + + /** + * Returns the active agent run ID for this request, lazily starting an + * {@link AgentRunWorkflow} if one has not been created yet. + * + *

Uses {@code "standalone"} as the agent name and {@code null} for prompt metadata. + * Prefer {@link #getOrActivate(String, String, String)} when agent metadata is available. + * + * @return the active agent run ID + */ + public String getOrActivate() { + return getOrActivate(null, null, null); + } + + /** + * Signals the active {@link AgentRunWorkflow} that the {@code @Agent} method has finished, + * then unregisters the run and clears the context holder. + * + *

Called directly by the generated CDI decorator when the {@code @Agent} method + * exits (successfully or via exception). Setting {@code agentRunId} to {@code null} afterward + * makes {@link #cleanup()} a no-op, preventing a duplicate {@code "done"} event. + * + *

When no decorator was generated (e.g., the lazy-activation fallback path used by + * {@link DaprChatModelDecorator}), this method is called by {@link #cleanup()} when the + * CDI request scope ends. + */ + public void triggerDone() { + if (agentRunId != null) { + LOG.infof("[AgentRun:%s] @Agent method exited — sending done event to AgentRunWorkflow", + agentRunId); + try { + workflowClient.raiseEvent(agentRunId, "agent-event", + new AgentEvent("done", null, null, null)); + } finally { + DaprAgentRunRegistry.unregister(agentRunId); + DaprAgentContextHolder.clear(); + agentRunId = null; // prevents @PreDestroy from firing a second time + } + } + } + + /** + * Safety-net called when the CDI request scope is destroyed. + * + *

In the normal flow the generated CDI decorator already called {@link #triggerDone()}, + * so {@code agentRunId} is {@code null} and this method is a no-op. It only fires the + * {@code "done"} event when the lazy-activation fallback path was used (i.e., no decorator + * was present for this {@code @Agent} interface). + */ + @PreDestroy + void cleanup() { + triggerDone(); + } +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/DaprAgentContextHolder.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/DaprAgentContextHolder.java new file mode 100644 index 000000000..d26d54c1d --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/DaprAgentContextHolder.java @@ -0,0 +1,54 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.agent; + +/** + * Thread-local holder for the current Dapr agent run ID. + * + *

Set by {@link io.quarkiverse.dapr.langchain4j.workflow.DaprWorkflowPlanner} before an agent + * begins execution, so that {@link DaprToolCallInterceptor} can detect when a tool call + * is happening inside a Dapr-backed agent and route it through a Dapr Workflow Activity. + */ +public class DaprAgentContextHolder { + + private static final ThreadLocal AGENT_RUN_ID = new ThreadLocal<>(); + + private DaprAgentContextHolder() { + } + + /** + * Sets the agent run ID for the current thread. + * + * @param agentRunId the agent run ID to set + */ + public static void set(String agentRunId) { + AGENT_RUN_ID.set(agentRunId); + } + + /** + * Returns the agent run ID for the current thread. + * + * @return the agent run ID, or {@code null} if not set + */ + public static String get() { + return AGENT_RUN_ID.get(); + } + + /** + * Clears the agent run ID for the current thread. + */ + public static void clear() { + AGENT_RUN_ID.remove(); + } +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/DaprAgentInterceptorBinding.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/DaprAgentInterceptorBinding.java new file mode 100644 index 000000000..127cd557c --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/DaprAgentInterceptorBinding.java @@ -0,0 +1,39 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.agent; + +import jakarta.interceptor.InterceptorBinding; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Inherited; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * CDI interceptor binding that marks an {@code @Agent}-annotated method for + * automatic Dapr Workflow integration. + * + *

Applied at build time by {@code DaprAgenticProcessor} to all interface methods + * carrying the {@code @Agent} annotation. This causes {@link DaprAgentMethodInterceptor} + * to fire when the method is called, starting an + * {@link io.quarkiverse.dapr.langchain4j.agent.workflow.AgentRunWorkflow} + * so that every tool call the agent makes runs inside a Dapr Workflow Activity. + */ +@InterceptorBinding +@Target({ ElementType.METHOD, ElementType.TYPE }) +@Retention(RetentionPolicy.RUNTIME) +@Inherited +public @interface DaprAgentInterceptorBinding { +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/DaprAgentMetadataHolder.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/DaprAgentMetadataHolder.java new file mode 100644 index 000000000..95b255a84 --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/DaprAgentMetadataHolder.java @@ -0,0 +1,63 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.agent; + +/** + * Thread-local holder for {@code @Agent} annotation metadata. + * + *

The generated CDI decorator sets this at the start of every {@code @Agent} method call + * so that {@link DaprChatModelDecorator} can retrieve the real agent name, user message, + * and system message when it lazily activates a workflow — instead of falling back to + * {@code "standalone"} with {@code null} messages. + */ +public final class DaprAgentMetadataHolder { + + /** + * Metadata record for agent name, user message, and system message. + */ + public record AgentMetadata(String agentName, String userMessage, String systemMessage) { + } + + private static final ThreadLocal METADATA = new ThreadLocal<>(); + + private DaprAgentMetadataHolder() { + } + + /** + * Sets the agent metadata for the current thread. + * + * @param agentName the agent name + * @param userMessage the user message template + * @param systemMessage the system message template + */ + public static void set(String agentName, String userMessage, String systemMessage) { + METADATA.set(new AgentMetadata(agentName, userMessage, systemMessage)); + } + + /** + * Returns the agent metadata for the current thread. + * + * @return the agent metadata, or {@code null} if not set + */ + public static AgentMetadata get() { + return METADATA.get(); + } + + /** + * Clears the agent metadata for the current thread. + */ + public static void clear() { + METADATA.remove(); + } +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/DaprAgentMethodInterceptor.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/DaprAgentMethodInterceptor.java new file mode 100644 index 000000000..4a5502d8f --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/DaprAgentMethodInterceptor.java @@ -0,0 +1,139 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.agent; + +import dev.langchain4j.agentic.Agent; +import dev.langchain4j.service.SystemMessage; +import dev.langchain4j.service.UserMessage; +import io.dapr.workflows.client.DaprWorkflowClient; +import io.quarkiverse.dapr.langchain4j.agent.workflow.AgentEvent; +import io.quarkiverse.dapr.langchain4j.agent.workflow.AgentRunInput; +import io.quarkiverse.dapr.langchain4j.agent.workflow.AgentRunWorkflow; +import io.quarkiverse.dapr.langchain4j.workflow.WorkflowNameResolver; +import jakarta.annotation.Priority; +import jakarta.inject.Inject; +import jakarta.interceptor.AroundInvoke; +import jakarta.interceptor.Interceptor; +import jakarta.interceptor.InvocationContext; +import org.jboss.logging.Logger; + +import java.lang.reflect.Method; +import java.util.UUID; + +/** + * CDI interceptor that starts a Dapr {@link AgentRunWorkflow} for any standalone + * {@code @Agent}-annotated method invocation. + * + *

Note: In practice this interceptor only fires when the {@code @Agent} + * method belongs to a regular CDI bean. The quarkus-langchain4j agentic extension + * registers {@code @Agent} interfaces as synthetic beans (via + * {@code SyntheticBeanBuildItem}) without interception enabled, so this interceptor will + * not fire for typical {@code @Agent} AiService calls. + * + *

For standalone {@code @Agent} calls, the workflow lifecycle is instead managed lazily by + * {@link AgentRunLifecycleManager}, which is triggered from + * {@link DaprToolCallInterceptor} on the first {@code @Tool} call of the request. + * + *

This class is retained for use cases where {@code @Agent} methods are declared on + * regular CDI beans (not synthetic AiService beans), and for potential future quarkus-langchain4j + * releases that enable interception on AiService synthetic beans. + */ +@DaprAgentInterceptorBinding +@Interceptor +@Priority(Interceptor.Priority.APPLICATION) +public class DaprAgentMethodInterceptor { + + private static final Logger LOG = Logger.getLogger(DaprAgentMethodInterceptor.class); + + @Inject + DaprWorkflowClient workflowClient; + + /** + * Intercepts {@code @Agent}-annotated method calls and starts a Dapr workflow. + * + * @param ctx the invocation context + * @return the result of the intercepted method + * @throws Exception if the intercepted method throws + */ + @AroundInvoke + public Object intercept(InvocationContext ctx) throws Exception { + // If already inside an orchestration-driven agent run (AgentExecutionActivity set this), + // don't start another workflow — just proceed. + if (DaprAgentContextHolder.get() != null) { + return ctx.proceed(); + } + + // Standalone @Agent call — start a new AgentRunWorkflow for this invocation. + String agentRunId = UUID.randomUUID().toString(); + Method method = ctx.getMethod(); + String agentName = extractAgentName(method, ctx.getTarget().getClass()); + String userMessage = extractUserMessageTemplate(method); + String systemMessage = extractSystemMessageTemplate(method); + + LOG.infof("[AgentRun:%s] DaprAgentMethodInterceptor: starting AgentRunWorkflow for %s", + agentRunId, agentName); + + AgentRunContext runContext = new AgentRunContext(agentRunId); + DaprAgentRunRegistry.register(agentRunId, runContext); + workflowClient.scheduleNewWorkflow( + WorkflowNameResolver.resolve(AgentRunWorkflow.class), + new AgentRunInput(agentRunId, agentName, userMessage, systemMessage), agentRunId); + DaprAgentContextHolder.set(agentRunId); + + try { + return ctx.proceed(); + } finally { + LOG.infof("[AgentRun:%s] DaprAgentMethodInterceptor: @Agent method completed, sending done event", + agentRunId); + workflowClient.raiseEvent(agentRunId, "agent-event", + new AgentEvent("done", null, null, null)); + DaprAgentRunRegistry.unregister(agentRunId); + DaprAgentContextHolder.clear(); + } + } + + /** + * Returns the {@code @Agent(name)} value if non-blank, otherwise falls back to + * {@code DeclaringInterface.methodName} for CDI beans. + */ + private String extractAgentName(Method method, Class targetClass) { + Agent agentAnnotation = method.getAnnotation(Agent.class); + if (agentAnnotation != null && !agentAnnotation.name().isBlank()) { + return agentAnnotation.name(); + } + return targetClass.getSimpleName() + "." + method.getName(); + } + + /** + * Returns the joined {@code @UserMessage} template text, or {@code null} if not present. + */ + private String extractUserMessageTemplate(Method method) { + UserMessage annotation = method.getAnnotation(UserMessage.class); + if (annotation != null && annotation.value().length > 0) { + return String.join("\n", annotation.value()); + } + return null; + } + + /** + * Returns the joined {@code @SystemMessage} template text, or {@code null} if not present. + */ + private String extractSystemMessageTemplate(Method method) { + SystemMessage annotation = method.getAnnotation(SystemMessage.class); + if (annotation != null && annotation.value().length > 0) { + return String.join("\n", annotation.value()); + } + return null; + } +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/DaprAgentRunRegistry.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/DaprAgentRunRegistry.java new file mode 100644 index 000000000..f098bc3b1 --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/DaprAgentRunRegistry.java @@ -0,0 +1,72 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.agent; + +import java.util.Map; +import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; + +/** + * Static registry that maps agent run IDs to their {@link AgentRunContext}. + * + *

Similar to {@link io.quarkiverse.dapr.langchain4j.workflow.DaprPlannerRegistry} but for + * individual agent executions. Allows + * {@link io.quarkiverse.dapr.langchain4j.agent.activities.ToolCallActivity} + * to look up the in-progress context for a given agent run ID. + */ +public class DaprAgentRunRegistry { + + private static final Map REGISTRY = new ConcurrentHashMap<>(); + + private DaprAgentRunRegistry() { + } + + /** + * Registers an agent run context for the given agent run ID. + * + * @param agentRunId the agent run ID + * @param context the agent run context to register + */ + public static void register(String agentRunId, AgentRunContext context) { + REGISTRY.put(agentRunId, context); + } + + /** + * Returns the agent run context for the given agent run ID. + * + * @param agentRunId the agent run ID + * @return the agent run context, or {@code null} if not registered + */ + public static AgentRunContext get(String agentRunId) { + return REGISTRY.get(agentRunId); + } + + /** + * Unregisters the agent run context for the given agent run ID. + * + * @param agentRunId the agent run ID to unregister + */ + public static void unregister(String agentRunId) { + REGISTRY.remove(agentRunId); + } + + /** + * Returns the set of all registered agent run IDs. + * + * @return the set of registered agent run IDs + */ + public static Set getRegisteredIds() { + return REGISTRY.keySet(); + } +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/DaprAgentToolInterceptorBinding.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/DaprAgentToolInterceptorBinding.java new file mode 100644 index 000000000..172072a91 --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/DaprAgentToolInterceptorBinding.java @@ -0,0 +1,37 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.agent; + +import jakarta.interceptor.InterceptorBinding; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Inherited; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * CDI interceptor binding applied automatically (via Quarkus {@code AnnotationsTransformer}) + * to all {@code @Tool}-annotated methods on CDI beans. + * + *

The corresponding interceptor, {@link DaprToolCallInterceptor}, intercepts these methods + * and, when executing inside a Dapr-backed agent workflow, routes the tool call through + * a Dapr Workflow Activity instead of executing it directly. + */ +@InterceptorBinding +@Target({ ElementType.METHOD, ElementType.TYPE }) +@Retention(RetentionPolicy.RUNTIME) +@Inherited +public @interface DaprAgentToolInterceptorBinding { +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/DaprChatModelDecorator.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/DaprChatModelDecorator.java new file mode 100644 index 000000000..c9da204de --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/DaprChatModelDecorator.java @@ -0,0 +1,272 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.agent; + +import dev.langchain4j.model.chat.ChatModel; +import dev.langchain4j.model.chat.request.ChatRequest; +import dev.langchain4j.model.chat.response.ChatResponse; +import io.dapr.workflows.client.DaprWorkflowClient; +import io.quarkiverse.dapr.langchain4j.agent.workflow.AgentEvent; +import jakarta.annotation.Priority; +import jakarta.decorator.Decorator; +import jakarta.decorator.Delegate; +import jakarta.enterprise.context.Dependent; +import jakarta.enterprise.inject.Any; +import jakarta.enterprise.inject.Instance; +import jakarta.inject.Inject; +import jakarta.interceptor.Interceptor; +import org.jboss.logging.Logger; + +import java.lang.reflect.Method; +import java.util.List; +import java.util.UUID; +import java.util.concurrent.CompletableFuture; +/** + * CDI Decorator that routes {@code ChatModel.chat(ChatRequest)} calls through a Dapr + * Workflow Activity when executing inside an active agent run. + * + *

Why a decorator instead of a CDI interceptor

+ * quarkus-langchain4j registers {@code ChatModel} as a synthetic bean + * ({@code SyntheticBeanBuildItem}). Arc does not apply CDI interceptors to synthetic + * beans based on {@code AnnotationsTransformer} modifications to the interface — the + * synthetic bean proxy is generated without interceptor binding metadata. CDI decorators, + * however, work at the bean type level and are applied by Arc to any bean (including + * synthetic beans) whose types include the delegate type. + * + *

Execution flow

+ *
    + *
  1. The LangChain4j AiService calls {@code chatModel.chat(request)} which routes + * through this decorator.
    2. + *
  2. If a Dapr agent run is active (identified by {@link DaprAgentContextHolder}), the + * decorator registers a {@link AgentRunContext.PendingCall} and raises an + * {@code "llm-call"} event to the running + * {@link io.quarkiverse.dapr.langchain4j.agent.workflow.AgentRunWorkflow}.
    3. + *
  3. The decorator blocks the agent thread on a {@link CompletableFuture}.
    4. + *
  4. {@link io.quarkiverse.dapr.langchain4j.agent.activities.LlmCallActivity} picks up + * the event, sets {@link DaprToolCallInterceptor#IS_ACTIVITY_CALL}, and re-invokes + * this decorator's {@code chat()} method via reflection on the stored target.
    5. + *
  5. The decorator sees {@code IS_ACTIVITY_CALL} set and passes through to + * {@code delegate.chat(request)} — executing the real LLM call on the Dapr + * activity thread.
    6. + *
  6. The result is returned to {@code LlmCallActivity}, which completes the future, + * unblocking the agent thread.
    7. + *
+ * + *

Lazy activation

+ * When an {@code @Agent} method is called standalone (no orchestration workflow), + * the first LLM call will find no active {@code agentRunId} in {@link DaprAgentContextHolder}. + * This decorator calls {@link AgentRunLifecycleManager#getOrActivate()} to lazily start + * an {@link io.quarkiverse.dapr.langchain4j.agent.workflow.AgentRunWorkflow} so that all + * subsequent LLM and tool calls are routed through Dapr. + */ + +@Decorator +@Priority(Interceptor.Priority.APPLICATION) +@Dependent +public class DaprChatModelDecorator implements ChatModel { + + private static final Logger LOG = Logger.getLogger(DaprChatModelDecorator.class); + + @Inject + @Delegate + @Any + ChatModel delegate; + + @Inject + DaprWorkflowClient workflowClient; + + @Inject + Instance lifecycleManager; + + /** + * Explicit delegation for the {@code doChat()} template method. + * + *

The default {@link ChatModel#chat(ChatRequest)} implementation calls + * {@code this.doChat(ChatRequest)} internally. Because our decorator only overrides + * {@code chat()}, Arc does not generate a {@code doChat$superforward} bridge method in + * the decorated bean's Arc subclass proxy. Without it, the CDI delegate proxy cannot + * forward {@code doChat()} to the actual bean — it falls through to the interface + * default which throws {@code "Not implemented"}. + * + *

Overriding {@code doChat()} here — even as a pure delegation — causes Arc to generate + * the required bridge, so the internal {@code chat() → doChat()} chain resolves correctly + * through the delegate to the actual {@code ChatModel} implementation. + */ + @Override + public ChatResponse doChat(ChatRequest request) { + return delegate.doChat(request); + } + + @Override + public ChatResponse chat(ChatRequest request) { + // If called from LlmCallActivity (IS_ACTIVITY_CALL is set), this is the real + // execution — pass through to the real ChatModel without routing through Dapr. + if (Boolean.TRUE.equals(DaprToolCallInterceptor.IS_ACTIVITY_CALL.get())) { + return delegate.chat(request); + } + + // Check whether we are inside a Dapr-backed agent run. + String agentRunId = DaprAgentContextHolder.get(); + + if (agentRunId == null) { + // No orchestration context — try to lazily activate a workflow for this request. + // The first event in the ReAct loop is always an LLM call, so this is typically + // where the AgentRunWorkflow is started for standalone @Agent invocations. + // Pass the rendered messages so they are recorded in the workflow input. + agentRunId = tryLazyActivate(extractUserMessage(request), extractSystemMessage(request)); + if (agentRunId == null) { + // Not in a CDI request scope (e.g., background thread) — execute directly. + return delegate.chat(request); + } + } + + AgentRunContext runCtx = DaprAgentRunRegistry.get(agentRunId); + if (runCtx == null) { + return delegate.chat(request); + } + + // Register this LLM call and get a future for the result. + String llmCallId = UUID.randomUUID().toString(); + try { + // Store (this, chat-method, request) so LlmCallActivity can re-invoke + // this decorator's chat() with IS_ACTIVITY_CALL set, which passes through + // to delegate.chat(request) — the real LLM execution. + Method chatMethod = ChatModel.class.getMethod("chat", ChatRequest.class); + CompletableFuture future = runCtx.registerCall( + llmCallId, this, chatMethod, new Object[]{request}); + + // Extract the prompt for observability in the workflow history. + String prompt = extractPrompt(request); + + LOG.infof("[AgentRun:%s][LlmCall:%s] Routing LLM call through Dapr: chat()", + agentRunId, llmCallId); + + // Notify the AgentRunWorkflow that an LLM call is waiting. + // The prompt is passed as args so it is stored in the Dapr activity input. + workflowClient.raiseEvent(agentRunId, "agent-event", + new AgentEvent("llm-call", llmCallId, "chat", prompt)); + + // Block the agent thread until LlmCallActivity completes the LLM execution. + return (ChatResponse) future.join(); + + } catch (NoSuchMethodException ex) { + LOG.warnf("[AgentRun:%s][LlmCall:%s] Could not find chat(ChatRequest) via reflection" + + " — falling back to direct call: %s", agentRunId, llmCallId, ex.getMessage()); + return delegate.chat(request); + } + } + + /** + * Lazily activates an {@link AgentRunLifecycleManager} for the current CDI request scope, + * recording the rendered user and system messages in the workflow input for observability. + * + * @param userMessage the rendered user message extracted from the {@code ChatRequest} + * @param systemMessage the rendered system message extracted from the {@code ChatRequest} + * @return the new {@code agentRunId}, or {@code null} if no request scope is active + */ + private String tryLazyActivate(String userMessage, String systemMessage) { + try { + // Check whether the generated CDI decorator stored @Agent metadata on this thread. + // This provides the real agent name and annotation-level messages even when the + // decorator's own getOrActivate() call failed and fell through to direct delegation. + DaprAgentMetadataHolder.AgentMetadata metadata = DaprAgentMetadataHolder.get(); + String agentName = "standalone"; + if (metadata != null) { + agentName = metadata.agentName(); + if (userMessage == null) { + userMessage = metadata.userMessage(); + } + if (systemMessage == null) { + systemMessage = metadata.systemMessage(); + } + DaprAgentMetadataHolder.clear(); + } + String agentRunId = lifecycleManager.get().getOrActivate(agentName, userMessage, systemMessage); + LOG.infof("[AgentRun:%s] Lazy activation triggered by first LLM call (agent=%s)", + agentRunId, agentName); + return agentRunId; + } catch (Exception ex) { + LOG.debugf("Could not lazily activate AgentRunWorkflow (no active request scope?): %s", + ex.getMessage()); + return null; + } + } + + /** + * Extracts the messages from a {@code ChatRequest} for observability in the workflow history. + * Uses reflection to avoid a hard version-specific dependency on langchain4j internals. + */ + private String extractPrompt(ChatRequest request) { + if (request == null) { + return null; + } + try { + Object messages = request.getClass().getMethod("messages").invoke(request); + return String.valueOf(messages); + } catch (Exception ex) { + return String.valueOf(request); + } + } + + /** + * Extracts the last (most recent) user message text from the {@code ChatRequest}. + * Uses reflection to remain decoupled from specific langchain4j internals. + */ + private String extractUserMessage(ChatRequest request) { + if (request == null) { + return null; + } + try { + List messages = (List) request.getClass().getMethod("messages").invoke(request); + for (int ii = messages.size() - 1; ii >= 0; ii--) { + Object msg = messages.get(ii); + if ("UserMessage".equals(msg.getClass().getSimpleName())) { + try { + return (String) msg.getClass().getMethod("singleText").invoke(msg); + } catch (ReflectiveOperationException ex) { + return String.valueOf(msg); + } + } + } + } catch (ReflectiveOperationException ignored) { + // intentionally empty + } + return null; + } + + /** + * Extracts the system message text from the {@code ChatRequest}. + * Uses reflection to remain decoupled from specific langchain4j internals. + */ + private String extractSystemMessage(ChatRequest request) { + if (request == null) { + return null; + } + try { + List messages = (List) request.getClass().getMethod("messages").invoke(request); + for (Object msg : messages) { + if ("SystemMessage".equals(msg.getClass().getSimpleName())) { + try { + return (String) msg.getClass().getMethod("text").invoke(msg); + } catch (ReflectiveOperationException ex) { + return String.valueOf(msg); + } + } + } + } catch (ReflectiveOperationException ignored) { + // intentionally empty + } + return null; + } +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/DaprToolCallInterceptor.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/DaprToolCallInterceptor.java new file mode 100644 index 000000000..95f5d00ac --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/DaprToolCallInterceptor.java @@ -0,0 +1,145 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.agent; + +import io.dapr.workflows.client.DaprWorkflowClient; +import io.quarkiverse.dapr.langchain4j.agent.workflow.AgentEvent; +import jakarta.annotation.Priority; +import jakarta.enterprise.inject.Instance; +import jakarta.inject.Inject; +import jakarta.interceptor.AroundInvoke; +import jakarta.interceptor.Interceptor; +import jakarta.interceptor.InvocationContext; +import org.jboss.logging.Logger; + +import java.util.Arrays; +import java.util.UUID; +import java.util.concurrent.CompletableFuture; +/** + * CDI interceptor that routes {@code @Tool}-annotated method calls through a Dapr Workflow + * Activity when executing inside a Dapr-backed agent run. + * + *

Execution flow (orchestration-driven)

+ * When an agent is run via an orchestration workflow ({@code @SequenceAgent} etc.), + * {@code AgentExecutionActivity} sets {@link DaprAgentContextHolder} before the agent starts. + * Tool calls find a non-null {@code agentRunId} and are routed through + * {@link io.quarkiverse.dapr.langchain4j.agent.activities.ToolCallActivity}. + * + *

Execution flow (standalone {@code @Agent})

+ * When an {@code @Agent}-annotated method is called directly (without an orchestrator), + * {@link DaprAgentContextHolder} is null on the first tool call. In this case the interceptor + * calls {@link AgentRunLifecycleManager#getOrActivate()} to lazily start an + * {@link io.quarkiverse.dapr.langchain4j.agent.workflow.AgentRunWorkflow} and set the context. + * The workflow is terminated by {@link AgentRunLifecycleManager}'s {@code @PreDestroy} when the + * CDI request scope ends. + * + *

Deadlock prevention

+ * {@code ToolCallActivity} calls the {@code @Tool} method via reflection on the CDI proxy. This + * would cause the interceptor to fire again. The {@link #IS_ACTIVITY_CALL} {@code ThreadLocal} + * prevents recursion: when set on the activity thread, the interceptor calls {@code ctx.proceed()} + * immediately without routing through Dapr. + */ + +@DaprAgentToolInterceptorBinding +@Interceptor +@Priority(Interceptor.Priority.APPLICATION) +public class DaprToolCallInterceptor { + + private static final Logger LOG = Logger.getLogger(DaprToolCallInterceptor.class); + + /** + * Thread-local flag set by {@code ToolCallActivity} to indicate that the current call + * is the actual tool execution (not the routed interception), so the interceptor + * should proceed normally. + */ + public static final ThreadLocal IS_ACTIVITY_CALL = new ThreadLocal<>(); + + @Inject + DaprWorkflowClient workflowClient; + + @Inject + Instance lifecycleManager; + + /** + * Intercepts tool-annotated method calls and routes them through Dapr Workflow. + * + * @param ctx the invocation context + * @return the result of the tool call + * @throws Exception if the tool call fails + */ + @AroundInvoke + public Object intercept(InvocationContext ctx) throws Exception { + // If called from ToolCallActivity, this is the real execution — proceed normally. + if (Boolean.TRUE.equals(IS_ACTIVITY_CALL.get())) { + return ctx.proceed(); + } + + // Check whether we are inside a Dapr-backed agent run. + String agentRunId = DaprAgentContextHolder.get(); + + if (agentRunId == null) { + // No orchestration context — try to lazily activate a workflow for this request. + agentRunId = tryLazyActivate(ctx.getMethod().getName()); + if (agentRunId == null) { + // Not in a CDI request scope (e.g., background thread) — execute directly. + return ctx.proceed(); + } + } + + AgentRunContext runCtx = DaprAgentRunRegistry.get(agentRunId); + if (runCtx == null) { + return ctx.proceed(); + } + + // Register this tool call and get a future for the result. + String toolCallId = UUID.randomUUID().toString(); + final CompletableFuture future = runCtx.registerCall( + toolCallId, + ctx.getTarget(), + ctx.getMethod(), + ctx.getParameters()); + + String args = ""; + if (ctx.getParameters() != null) { + args = Arrays.toString(ctx.getParameters()); + } + + LOG.infof("[AgentRun:%s][ToolCall:%s] Routing tool call through Dapr: method=%s, args=%s", + agentRunId, toolCallId, ctx.getMethod().getName(), args); + + // Notify the AgentRunWorkflow that a tool call is waiting. + workflowClient.raiseEvent(agentRunId, "agent-event", + new AgentEvent("tool-call", toolCallId, ctx.getMethod().getName(), args)); + + // Block the agent thread until ToolCallActivity completes the tool execution. + return future.join(); + } + + /** + * Lazily activates an {@link AgentRunLifecycleManager} for the current CDI request scope. + * Returns the new {@code agentRunId}, or {@code null} if no request scope is active. + */ + private String tryLazyActivate(String toolMethodName) { + try { + String agentRunId = lifecycleManager.get().getOrActivate(); + LOG.infof("[AgentRun:%s] Lazy activation triggered by first tool call: %s", + agentRunId, toolMethodName); + return agentRunId; + } catch (Exception e) { + LOG.debugf("Could not lazily activate AgentRunWorkflow (no active request scope?): %s", + e.getMessage()); + return null; + } + } +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/activities/LlmCallActivity.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/activities/LlmCallActivity.java new file mode 100644 index 000000000..816001de8 --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/activities/LlmCallActivity.java @@ -0,0 +1,134 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.agent.activities; + +import io.dapr.workflows.WorkflowActivity; +import io.dapr.workflows.WorkflowActivityContext; +import io.quarkiverse.dapr.langchain4j.agent.AgentRunContext; +import io.quarkiverse.dapr.langchain4j.agent.DaprAgentRunRegistry; +import io.quarkiverse.dapr.langchain4j.agent.DaprToolCallInterceptor; +import io.quarkiverse.dapr.workflows.ActivityMetadata; +import jakarta.enterprise.context.ApplicationScoped; +import org.jboss.logging.Logger; + +import java.lang.reflect.InvocationTargetException; +/** + * Dapr Workflow Activity that executes a single {@code ChatModel.chat(ChatRequest)} call on + * behalf of a running {@link io.quarkiverse.dapr.langchain4j.agent.workflow.AgentRunWorkflow}. + * + *

How it works

+ *
    + *
  1. Receives {@link LlmCallInput} with the {@code agentRunId}, {@code llmCallId}, + * {@code methodName}, and the serialized {@code prompt} (messages sent to the LLM).
    2. + *
  2. Looks up the {@link AgentRunContext} from {@link DaprAgentRunRegistry}.
    3. + *
  3. Retrieves the {@link AgentRunContext.PendingCall} registered by + * {@link io.quarkiverse.dapr.langchain4j.agent.DaprLlmCallInterceptor}.
    4. + *
  4. Sets {@link DaprToolCallInterceptor#IS_ACTIVITY_CALL} on this thread so that + * {@code DaprChatModelDecorator} passes through to {@code delegate.chat()} when + * re-invoked via reflection on the stored decorator instance.
    5. + *
  5. Invokes the {@code ChatModel} method via reflection on the decorator instance.
    6. + *
  6. Extracts the response text from the {@code ChatResponse} via reflection + * ({@code aiMessage().text()}) and returns a {@link LlmCallOutput} containing the + * method name and response text — stored in the Dapr workflow history.
    7. + *
  7. Completes the {@code CompletableFuture} in the pending call, unblocking + * the agent thread waiting in {@code DaprChatModelDecorator.chat()}.
    8. + *
+ */ + +@ApplicationScoped +@ActivityMetadata(name = "llm-call") +public class LlmCallActivity implements WorkflowActivity { + + private static final Logger LOG = Logger.getLogger(LlmCallActivity.class); + + /** + * {@inheritDoc} + */ + @Override + public Object run(WorkflowActivityContext ctx) { + LlmCallInput input = ctx.getInput(LlmCallInput.class); + + LOG.infof("[AgentRun:%s][LlmCall:%s] LlmCallActivity started — method=%s", + input.agentRunId(), input.llmCallId(), input.methodName()); + if (input.prompt() != null) { + LOG.debugf("[AgentRun:%s][LlmCall:%s] Prompt:\n%s", + input.agentRunId(), input.llmCallId(), input.prompt()); + } + + AgentRunContext runCtx = DaprAgentRunRegistry.get(input.agentRunId()); + if (runCtx == null) { + throw new IllegalStateException( + "No AgentRunContext found for agentRunId: " + input.agentRunId() + + ". Registered IDs: " + DaprAgentRunRegistry.getRegisteredIds()); + } + + AgentRunContext.PendingCall pendingCall = runCtx.getPendingCall(input.llmCallId()); + if (pendingCall == null) { + throw new IllegalStateException( + "No PendingCall found for llmCallId: " + input.llmCallId() + + " in agentRunId: " + input.agentRunId()); + } + + LOG.infof("[AgentRun:%s][LlmCall:%s] Executing LLM call: %s", + input.agentRunId(), input.llmCallId(), pendingCall.method().getName()); + + // Set the flag so DaprChatModelDecorator passes through on this thread instead of routing. + DaprToolCallInterceptor.IS_ACTIVITY_CALL.set(Boolean.TRUE); + try { + // Invoke chat() on the stored DaprChatModelDecorator instance via reflection. + // IS_ACTIVITY_CALL is set, so the decorator calls delegate.chat() directly. + Object result = pendingCall.method().invoke(pendingCall.target(), pendingCall.args()); + String responseText = extractResponseText(result); + runCtx.completeCall(input.llmCallId(), result); + LOG.infof("[AgentRun:%s][LlmCall:%s] LLM call completed: %s → %s", + input.agentRunId(), input.llmCallId(), pendingCall.method().getName(), responseText); + return new LlmCallOutput(input.methodName(), input.prompt(), responseText); + } catch (InvocationTargetException ite) { + Throwable cause = ite.getCause() != null ? ite.getCause() : ite; + LOG.errorf("[AgentRun:%s][LlmCall:%s] LLM call failed: %s — %s", + input.agentRunId(), input.llmCallId(), pendingCall.method().getName(), cause.getMessage()); + runCtx.failCall(input.llmCallId(), cause); + throw new RuntimeException("LLM call failed: " + pendingCall.method().getName(), cause); + } catch (Exception e) { + LOG.errorf("[AgentRun:%s][LlmCall:%s] LLM call failed: %s — %s", + input.agentRunId(), input.llmCallId(), pendingCall.method().getName(), e.getMessage()); + runCtx.failCall(input.llmCallId(), e); + throw new RuntimeException("LLM call failed: " + pendingCall.method().getName(), e); + } finally { + DaprToolCallInterceptor.IS_ACTIVITY_CALL.remove(); + } + } + + /** + * Extracts the AI response text from a {@code ChatResponse} object using reflection, + * avoiding a hard compile-time dependency on a specific LangChain4j package path. + * Calls {@code chatResponse.aiMessage().text()} if available; falls back to + * {@code String.valueOf(result)} otherwise. + */ + private String extractResponseText(Object result) { + if (result == null) { + return null; + } + try { + Object aiMessage = result.getClass().getMethod("aiMessage").invoke(result); + if (aiMessage != null) { + Object text = aiMessage.getClass().getMethod("text").invoke(aiMessage); + return String.valueOf(text); + } + } catch (ReflectiveOperationException ignored) { + // Not a ChatResponse or missing expected methods — fall through. + } + return String.valueOf(result); + } +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/activities/LlmCallInput.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/activities/LlmCallInput.java new file mode 100644 index 000000000..706740098 --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/activities/LlmCallInput.java @@ -0,0 +1,30 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.agent.activities; + +/** + * Input record for {@link LlmCallActivity}, identifying the specific LLM call to execute. + * + * @param agentRunId the ID of the {@code AgentRunWorkflow} instance + * @param llmCallId the unique ID of the pending LLM call registered in + * {@link io.quarkiverse.dapr.langchain4j.agent.AgentRunContext} + * @param methodName name of the {@code ChatModel} method being called (e.g., {@code "chat"}); + * stored in the Dapr activity input for observability in the workflow history + * @param prompt string representation of the {@code ChatRequest} messages sent to the LLM; + * extracted by {@link io.quarkiverse.dapr.langchain4j.agent.DaprLlmCallInterceptor} + * and stored in the Dapr activity input so the full prompt is visible in the + * workflow history without needing to inspect in-process state + */ +public record LlmCallInput(String agentRunId, String llmCallId, String methodName, String prompt) { +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/activities/LlmCallOutput.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/activities/LlmCallOutput.java new file mode 100644 index 000000000..96897f9dc --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/activities/LlmCallOutput.java @@ -0,0 +1,29 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.agent.activities; + +/** + * Output record returned by {@link LlmCallActivity} after a {@code ChatModel.chat()} + * call has been executed. Stored in the Dapr workflow history so the full LLM turn + * (prompt in, response out) is visible without inspecting in-process state. + * + * @param methodName name of the {@code ChatModel} method that was invoked (e.g., {@code "chat"}) + * @param prompt serialized {@code ChatRequest} messages that were sent to the model; + * extracted from the {@code ChatRequest} argument by + * {@link io.quarkiverse.dapr.langchain4j.agent.DaprLlmCallInterceptor} + * @param response AI response text extracted from {@code ChatResponse.aiMessage().text()}; + * this is the exact text the model returned to the agent + */ +public record LlmCallOutput(String methodName, String prompt, String response) { +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/activities/ToolCallActivity.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/activities/ToolCallActivity.java new file mode 100644 index 000000000..2cecd429b --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/activities/ToolCallActivity.java @@ -0,0 +1,100 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.agent.activities; + +import io.dapr.workflows.WorkflowActivity; +import io.dapr.workflows.WorkflowActivityContext; +import io.quarkiverse.dapr.langchain4j.agent.AgentRunContext; +import io.quarkiverse.dapr.langchain4j.agent.DaprAgentRunRegistry; +import io.quarkiverse.dapr.langchain4j.agent.DaprToolCallInterceptor; +import io.quarkiverse.dapr.workflows.ActivityMetadata; +import jakarta.enterprise.context.ApplicationScoped; +import org.jboss.logging.Logger; + +import java.lang.reflect.InvocationTargetException; +/** + * Dapr Workflow Activity that executes a single {@code @Tool}-annotated method call on + * behalf of a running {@link io.quarkiverse.dapr.langchain4j.agent.workflow.AgentRunWorkflow}. + * + *

How it works

+ *
    + *
  1. Receives {@link ToolCallInput} with the {@code agentRunId} and {@code toolCallId}.
    2. + *
  2. Looks up the {@link AgentRunContext} from {@link DaprAgentRunRegistry}.
    3. + *
  3. Retrieves the {@link AgentRunContext.PendingCall} registered by + * {@link io.quarkiverse.dapr.langchain4j.agent.DaprToolCallInterceptor}.
    4. + *
  4. Sets {@link DaprToolCallInterceptor#IS_ACTIVITY_CALL} on this thread so that + * the CDI interceptor passes through when the method is called via the CDI proxy.
    5. + *
  5. Invokes the {@code @Tool} method via reflection on the CDI proxy.
    6. + *
  6. Completes the {@code CompletableFuture} stored in the pending call, unblocking + * the agent thread waiting in {@code DaprToolCallInterceptor.intercept()}.
    7. + *
+ */ + +@ApplicationScoped +@ActivityMetadata(name = "tool-call") +public class ToolCallActivity implements WorkflowActivity { + + private static final Logger LOG = Logger.getLogger(ToolCallActivity.class); + + @Override + public Object run(WorkflowActivityContext ctx) { + ToolCallInput input = ctx.getInput(ToolCallInput.class); + + LOG.infof("[AgentRun:%s][ToolCall:%s] ToolCallActivity started — tool=%s, args=%s", + input.agentRunId(), input.toolCallId(), input.toolName(), input.args()); + + AgentRunContext runCtx = DaprAgentRunRegistry.get(input.agentRunId()); + if (runCtx == null) { + throw new IllegalStateException( + "No AgentRunContext found for agentRunId: " + input.agentRunId() + + ". Registered IDs: " + DaprAgentRunRegistry.getRegisteredIds()); + } + + AgentRunContext.PendingCall pendingCall = runCtx.getPendingCall(input.toolCallId()); + if (pendingCall == null) { + throw new IllegalStateException( + "No PendingCall found for toolCallId: " + input.toolCallId() + + " in agentRunId: " + input.agentRunId()); + } + + LOG.infof("[AgentRun:%s][ToolCall:%s] Executing tool method: %s", + input.agentRunId(), input.toolCallId(), pendingCall.method().getName()); + + // Set the flag so the CDI interceptor passes through on this thread. + DaprToolCallInterceptor.IS_ACTIVITY_CALL.set(Boolean.TRUE); + try { + // Invoke the @Tool method via the CDI proxy. + // The CDI interceptor will fire again but pass through because IS_ACTIVITY_CALL is set. + Object result = pendingCall.method().invoke(pendingCall.target(), pendingCall.args()); + String resultStr = String.valueOf(result); + runCtx.completeCall(input.toolCallId(), result); + LOG.infof("[AgentRun:%s][ToolCall:%s] Tool method completed: %s → %s", + input.agentRunId(), input.toolCallId(), pendingCall.method().getName(), resultStr); + return new ToolCallOutput(input.toolName(), input.args(), resultStr); + } catch (InvocationTargetException ite) { + Throwable cause = ite.getCause() != null ? ite.getCause() : ite; + LOG.errorf("[AgentRun:%s][ToolCall:%s] Tool method failed: %s — %s", + input.agentRunId(), input.toolCallId(), pendingCall.method().getName(), cause.getMessage()); + runCtx.failCall(input.toolCallId(), cause); + throw new RuntimeException("Tool execution failed: " + pendingCall.method().getName(), cause); + } catch (Exception e) { + LOG.errorf("[AgentRun:%s][ToolCall:%s] Tool method failed: %s — %s", + input.agentRunId(), input.toolCallId(), pendingCall.method().getName(), e.getMessage()); + runCtx.failCall(input.toolCallId(), e); + throw new RuntimeException("Tool execution failed: " + pendingCall.method().getName(), e); + } finally { + DaprToolCallInterceptor.IS_ACTIVITY_CALL.remove(); + } + } +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/activities/ToolCallInput.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/activities/ToolCallInput.java new file mode 100644 index 000000000..9e0735d62 --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/activities/ToolCallInput.java @@ -0,0 +1,28 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.agent.activities; + +/** + * Input record for {@link ToolCallActivity}. + * + * @param agentRunId the agent run ID used to look up the + * {@link io.quarkiverse.dapr.langchain4j.agent.AgentRunContext} + * @param toolCallId the unique tool call ID used to look up the pending + * {@link io.quarkiverse.dapr.langchain4j.agent.AgentRunContext.PendingCall} + * @param toolName name of the {@code @Tool}-annotated method being executed; stored in the + * Dapr activity input for observability in the workflow history + * @param args string representation of the arguments passed to the tool method + */ +public record ToolCallInput(String agentRunId, String toolCallId, String toolName, String args) { +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/activities/ToolCallOutput.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/activities/ToolCallOutput.java new file mode 100644 index 000000000..649bca6f2 --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/activities/ToolCallOutput.java @@ -0,0 +1,26 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.agent.activities; + +/** + * Output record returned by {@link ToolCallActivity} after a {@code @Tool}-annotated + * method has been executed. Stored in the Dapr workflow history so callers can + * inspect what each tool call produced. + * + * @param toolName name of the {@code @Tool} method that was invoked + * @param args string representation of the arguments that were passed to the tool + * @param result string representation of the value returned by the tool method + */ +public record ToolCallOutput(String toolName, String args, String result) { +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/workflow/AgentEvent.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/workflow/AgentEvent.java new file mode 100644 index 000000000..49e3d49bc --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/workflow/AgentEvent.java @@ -0,0 +1,36 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.agent.workflow; + +/** + * External event sent to {@link AgentRunWorkflow} via {@code DaprWorkflowClient.raiseEvent()}. + * + *

Two event types are used: + *

    + *
  • {@code "tool-call"} — a {@code @Tool}-annotated method was intercepted; the workflow + * should schedule a {@link io.quarkiverse.dapr.langchain4j.agent.activities.ToolCallActivity}.
    • + *
  • {@code "done"} — the agent has finished executing; the workflow should terminate.
    • + *
+ * + * @param type event discriminator: {@code "tool-call"} or {@code "done"} + * @param toolCallId unique ID for this tool call (null for "done" events) + * @param toolName name of the tool method being called (null for "done" events) + * @param args serialized arguments (reserved for future use; null for now) + */ +public record AgentEvent( + String type, + String toolCallId, + String toolName, + String args) { +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/workflow/AgentRunInput.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/workflow/AgentRunInput.java new file mode 100644 index 000000000..9e9b04313 --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/workflow/AgentRunInput.java @@ -0,0 +1,31 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.agent.workflow; + +/** + * Input record for {@link AgentRunWorkflow}. + * + * @param agentRunId unique ID correlating the Dapr Workflow instance to its in-memory + * {@link io.quarkiverse.dapr.langchain4j.agent.AgentRunContext} + * @param agentName human-readable name from {@code @Agent(name)} (or class+method for CDI + * beans), used for observability in the Dapr workflow history + * @param userMessage the {@code @UserMessage} template text (CDI bean path) or the first + * rendered user message from the {@code ChatRequest} (AiService path); + * may be {@code null} when started by an orchestration activity + * @param systemMessage the {@code @SystemMessage} template text (CDI bean path) or the + * rendered system message from the {@code ChatRequest} (AiService path); + * may be {@code null} + */ +public record AgentRunInput(String agentRunId, String agentName, String userMessage, String systemMessage) { +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/workflow/AgentRunOutput.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/workflow/AgentRunOutput.java new file mode 100644 index 000000000..75a895d88 --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/workflow/AgentRunOutput.java @@ -0,0 +1,47 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.agent.workflow; + +import io.quarkiverse.dapr.langchain4j.agent.activities.LlmCallOutput; +import io.quarkiverse.dapr.langchain4j.agent.activities.ToolCallOutput; + +import java.util.Collections; +import java.util.List; + +/** + * Aggregated output of a completed {@link AgentRunWorkflow}. Set as the Dapr + * workflow custom status after every activity so observers can follow execution + * progress in real time, and reflects the final state once {@code "done"} is received. + * + * @param agentName human-readable name of the {@code @Agent} that was executed + * @param toolCalls ordered list of tool calls made by the agent, each with its + * input arguments and return value + * @param llmCalls ordered list of LLM calls made by the agent, each with the + * model method name and the response text + */ +public record AgentRunOutput( + String agentName, + List toolCalls, + List llmCalls) { + + /** + * Creates an AgentRunOutput with unmodifiable defensive copies of the lists. + */ + public AgentRunOutput(String agentName, List toolCalls, + List llmCalls) { + this.agentName = agentName; + this.toolCalls = toolCalls == null ? null : Collections.unmodifiableList(List.copyOf(toolCalls)); + this.llmCalls = llmCalls == null ? null : Collections.unmodifiableList(List.copyOf(llmCalls)); + } +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/workflow/AgentRunWorkflow.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/workflow/AgentRunWorkflow.java new file mode 100644 index 000000000..e7c43109a --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/agent/workflow/AgentRunWorkflow.java @@ -0,0 +1,126 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.agent.workflow; + +import io.dapr.workflows.Workflow; +import io.dapr.workflows.WorkflowStub; +import io.quarkiverse.dapr.langchain4j.agent.activities.LlmCallActivity; +import io.quarkiverse.dapr.langchain4j.agent.activities.LlmCallInput; +import io.quarkiverse.dapr.langchain4j.agent.activities.LlmCallOutput; +import io.quarkiverse.dapr.langchain4j.agent.activities.ToolCallActivity; +import io.quarkiverse.dapr.langchain4j.agent.activities.ToolCallInput; +import io.quarkiverse.dapr.langchain4j.agent.activities.ToolCallOutput; +import io.quarkiverse.dapr.workflows.WorkflowMetadata; +import jakarta.enterprise.context.ApplicationScoped; +import org.jboss.logging.Logger; + +import java.util.ArrayList; +import java.util.List; +/** + * Dapr Workflow representing the execution of a single {@code @Agent}-annotated method, + * including all tool and LLM calls the agent makes during its ReAct loop. + * + *

Lifecycle

+ *
    + *
  1. Started by {@link io.quarkiverse.dapr.langchain4j.workflow.orchestration.activities.AgentExecutionActivity} + * (orchestration path) or lazily by {@link io.quarkiverse.dapr.langchain4j.agent.AgentRunLifecycleManager} + * (standalone {@code @Agent} path) just before the agent is submitted.
    2. + *
  2. Loops waiting for {@code "agent-event"} external events raised by + * {@link io.quarkiverse.dapr.langchain4j.agent.DaprToolCallInterceptor} and + * {@link io.quarkiverse.dapr.langchain4j.agent.DaprLlmCallInterceptor}.
    3. + *
  3. For each {@code "tool-call"} event, schedules a {@link ToolCallActivity} that + * executes the tool on the Dapr activity thread and returns a {@link ToolCallOutput}.
    4. + *
  4. For each {@code "llm-call"} event, schedules a {@link LlmCallActivity} that + * executes the LLM call on the Dapr activity thread and returns a {@link LlmCallOutput}.
    5. + *
  5. After each activity, updates the Dapr custom status with an {@link AgentRunOutput} + * snapshot so observers can follow execution progress in real time.
    6. + *
  6. Terminates when a {@code "done"} event is received, setting the final + * {@link AgentRunOutput} as the custom status.
    7. + *
+ */ + +@ApplicationScoped +@WorkflowMetadata(name = "agent") +public class AgentRunWorkflow implements Workflow { + + private static final Logger LOG = Logger.getLogger(AgentRunWorkflow.class); + + @Override + public WorkflowStub create() { + return ctx -> { + AgentRunInput input = ctx.getInput(AgentRunInput.class); + String agentRunId = input.agentRunId(); + String agentName = input.agentName(); + + LOG.infof("[AgentRun:%s] AgentRunWorkflow started — agent=%s, userMessage=%s, systemMessage=%s", + agentRunId, agentName, + truncate(input.userMessage(), 120), + truncate(input.systemMessage(), 120)); + + List toolCallOutputs = new ArrayList<>(); + List llmCallOutputs = new ArrayList<>(); + + while (true) { + // Wait for the next event from the agent thread or completion signal. + AgentEvent event = ctx.waitForExternalEvent("agent-event", AgentEvent.class).await(); + + LOG.infof("[AgentRun:%s] Received event: type=%s, callId=%s, name=%s", + agentRunId, event.type(), event.toolCallId(), event.toolName()); + + if ("done".equals(event.type())) { + LOG.infof("[AgentRun:%s] AgentRunWorkflow completed — agent=%s, toolCalls=%d, llmCalls=%d", + agentRunId, agentName, toolCallOutputs.size(), llmCallOutputs.size()); + break; + } + + if ("tool-call".equals(event.type())) { + LOG.infof("[AgentRun:%s] Scheduling ToolCallActivity — tool=%s, args=%s", + agentRunId, event.toolName(), event.args()); + ToolCallOutput toolOutput = ctx.callActivity( + "tool-call", + new ToolCallInput(agentRunId, event.toolCallId(), event.toolName(), event.args()), + ToolCallOutput.class).await(); + toolCallOutputs.add(toolOutput); + LOG.infof("[AgentRun:%s] ToolCallActivity completed — tool=%s → %s", + agentRunId, event.toolName(), toolOutput.result()); + ctx.setCustomStatus(new AgentRunOutput(agentName, toolCallOutputs, llmCallOutputs)); + } + + if ("llm-call".equals(event.type())) { + LOG.infof("[AgentRun:%s] Scheduling LlmCallActivity — method=%s", + agentRunId, event.toolName()); + LlmCallOutput llmOutput = ctx.callActivity( + "llm-call", + new LlmCallInput(agentRunId, event.toolCallId(), event.toolName(), event.args()), + LlmCallOutput.class).await(); + llmCallOutputs.add(llmOutput); + LOG.infof("[AgentRun:%s] LlmCallActivity completed — method=%s, response=%s", + agentRunId, event.toolName(), llmOutput.response()); + ctx.setCustomStatus(new AgentRunOutput(agentName, toolCallOutputs, llmCallOutputs)); + } + } + + // Set the final output so it is visible in the Dapr workflow dashboard. + ctx.setCustomStatus(new AgentRunOutput(agentName, toolCallOutputs, llmCallOutputs)); + }; + } + + private static String truncate(String s, int maxLength) { + if (s == null) { + return null; + } + String trimmed = s.strip(); + return trimmed.length() <= maxLength ? trimmed : trimmed.substring(0, maxLength) + "…"; + } +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/memory/KeyValueChatMemoryStore.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/memory/KeyValueChatMemoryStore.java new file mode 100644 index 000000000..9a5f81b91 --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/memory/KeyValueChatMemoryStore.java @@ -0,0 +1,91 @@ +/* + * Copyright 2025 The Dapr 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.quarkiverse.dapr.langchain4j.memory; + +import dev.langchain4j.data.message.ChatMessage; +import dev.langchain4j.data.message.ChatMessageDeserializer; +import dev.langchain4j.data.message.ChatMessageSerializer; +import dev.langchain4j.store.memory.chat.ChatMemoryStore; +import io.dapr.client.DaprClient; +import io.dapr.client.domain.State; + +import java.util.Collections; +import java.util.List; +import java.util.function.Function; + +/** + * A {@link ChatMemoryStore} backed by Dapr's key-value state store. + * + *

Messages are serialized to JSON using {@link ChatMessageSerializer} and stored + * under the key {@code memoryId.toString()} in the configured Dapr state store. + */ +public class KeyValueChatMemoryStore implements ChatMemoryStore { + + private final DaprClient daprClient; + private final String stateStoreName; + private final Function, String> serializer; + private final Function> deserializer; + + /** + * Creates a new KeyValueChatMemoryStore with default serializers. + * + * @param daprClient the Dapr client + * @param stateStoreName the state store name + */ + public KeyValueChatMemoryStore(DaprClient daprClient, String stateStoreName) { + this(daprClient, stateStoreName, + ChatMessageSerializer::messagesToJson, + ChatMessageDeserializer::messagesFromJson); + } + + /** + * Creates a new KeyValueChatMemoryStore with custom serializers. + * + * @param daprClient the Dapr client + * @param stateStoreName the state store name + * @param serializer the message serializer + * @param deserializer the message deserializer + */ + KeyValueChatMemoryStore(DaprClient daprClient, String stateStoreName, + Function, String> serializer, + Function> deserializer) { + this.daprClient = daprClient; + this.stateStoreName = stateStoreName; + this.serializer = serializer; + this.deserializer = deserializer; + } + + @Override + public List getMessages(Object memoryId) { + String key = memoryId.toString(); + State state = daprClient.getState(stateStoreName, key, String.class).block(); + if (state == null || state.getValue() == null || state.getValue().isEmpty()) { + return Collections.emptyList(); + } + return deserializer.apply(state.getValue()); + } + + @Override + public void updateMessages(Object memoryId, List messages) { + String key = memoryId.toString(); + String json = serializer.apply(messages); + daprClient.saveState(stateStoreName, key, json).block(); + } + + @Override + public void deleteMessages(Object memoryId) { + String key = memoryId.toString(); + daprClient.deleteState(stateStoreName, key).block(); + } +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/DaprAgentService.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/DaprAgentService.java new file mode 100644 index 000000000..c9eab1345 --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/DaprAgentService.java @@ -0,0 +1,29 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.workflow; + +/** + * Marker interface for Dapr-backed agent service implementations. + * Provides the Dapr Workflow type name used to schedule the orchestration. + */ +public interface DaprAgentService { + + /** + * Returns the simple class name of the Dapr Workflow to schedule + * for this orchestration pattern. + * + * @return the workflow type name + */ + String workflowType(); +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/DaprAgentServiceUtil.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/DaprAgentServiceUtil.java new file mode 100644 index 000000000..2900ee51e --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/DaprAgentServiceUtil.java @@ -0,0 +1,38 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.workflow; + +/** + * Shared utility methods for Dapr agent services. + */ +public final class DaprAgentServiceUtil { + + private DaprAgentServiceUtil() { + } + + /** + * Sanitizes a name for use as a Dapr workflow identifier. + * Replaces any non-alphanumeric characters (except hyphens and underscores) + * with underscores. + * + * @param name the name to sanitize + * @return the sanitized name + */ + public static String safeName(String name) { + if (name == null || name.isEmpty()) { + return "unnamed"; + } + return name.replaceAll("[^a-zA-Z0-9_-]", "_"); + } +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/DaprConditionalAgentService.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/DaprConditionalAgentService.java new file mode 100644 index 000000000..dce56702b --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/DaprConditionalAgentService.java @@ -0,0 +1,155 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.workflow; + +import dev.langchain4j.agentic.UntypedAgent; +import dev.langchain4j.agentic.declarative.ConditionalAgent; +import dev.langchain4j.agentic.internal.AgentExecutor; +import dev.langchain4j.agentic.internal.AgentUtil; +import dev.langchain4j.agentic.planner.AgenticSystemTopology; +import dev.langchain4j.agentic.scope.AgenticScope; +import dev.langchain4j.agentic.workflow.impl.ConditionalAgentServiceImpl; +import io.dapr.workflows.client.DaprWorkflowClient; +import io.quarkiverse.dapr.langchain4j.workflow.orchestration.ConditionalOrchestrationWorkflow; + +import java.util.HashMap; +import java.util.Map; +import java.util.function.Predicate; + +/** + * Conditional agent service backed by a Dapr Workflow. + * Extends {@link ConditionalAgentServiceImpl} and implements {@link DaprAgentService} + * to provide Dapr-based conditional orchestration. + */ +public class DaprConditionalAgentService extends ConditionalAgentServiceImpl implements DaprAgentService { + + private final DaprWorkflowClient workflowClient; + private final Map> daprConditions = new HashMap<>(); + private int agentCounter = 0; + + /** + * Creates a new conditional agent service for the given agent service class. + * + * @param agentServiceClass the agent service class to create the service for + * @param workflowClient the Dapr workflow client used for orchestration + */ + public DaprConditionalAgentService(Class agentServiceClass, DaprWorkflowClient workflowClient) { + super(agentServiceClass, resolveMethod(agentServiceClass)); + this.workflowClient = workflowClient; + } + + private static java.lang.reflect.Method resolveMethod(Class agentServiceClass) { + if (agentServiceClass == UntypedAgent.class) { + return null; + } + return AgentUtil.validateAgentClass(agentServiceClass, false, ConditionalAgent.class); + } + + /** + * {@inheritDoc} + */ + @Override + public String workflowType() { + return ConditionalOrchestrationWorkflow.class.getCanonicalName(); + } + + /** + * {@inheritDoc} + */ + @Override + public DaprConditionalAgentService subAgents(Predicate condition, Object... agents) { + for (int i = 0; i < agents.length; i++) { + daprConditions.put(agentCounter + i, condition); + } + agentCounter += agents.length; + super.subAgents(condition, agents); + return this; + } + + /** + * {@inheritDoc} + */ + @Override + public DaprConditionalAgentService subAgents(String conditionDescription, + Predicate condition, Object... agents) { + for (int i = 0; i < agents.length; i++) { + daprConditions.put(agentCounter + i, condition); + } + agentCounter += agents.length; + super.subAgents(conditionDescription, condition, agents); + return this; + } + + /** + * {@inheritDoc} + */ + @Override + public DaprConditionalAgentService subAgent(Predicate condition, AgentExecutor agent) { + daprConditions.put(agentCounter, condition); + agentCounter++; + super.subAgent(condition, agent); + return this; + } + + /** + * {@inheritDoc} + */ + @Override + public DaprConditionalAgentService subAgent(String conditionDescription, + Predicate condition, AgentExecutor agent) { + daprConditions.put(agentCounter, condition); + agentCounter++; + super.subAgent(conditionDescription, condition, agent); + return this; + } + + /** + * {@inheritDoc} + */ + @Override + public T build() { + return build(() -> { + DaprWorkflowPlanner planner = new DaprWorkflowPlanner( + ConditionalOrchestrationWorkflow.class, + "Conditional", + AgenticSystemTopology.ROUTER, + workflowClient); + planner.setConditions(daprConditions); + return planner; + }); + } + + /** + * Creates a builder for an untyped conditional agent service. + * + * @param workflowClient the Dapr workflow client used for orchestration + * @return a new untyped conditional agent service builder + */ + public static DaprConditionalAgentService builder(DaprWorkflowClient workflowClient) { + return new DaprConditionalAgentService<>(UntypedAgent.class, workflowClient); + } + + /** + * Creates a builder for a typed conditional agent service. + * + * @param the agent service type + * @param agentServiceClass the agent service class to create the builder for + * @param workflowClient the Dapr workflow client used for orchestration + * @return a new typed conditional agent service builder + */ + public static DaprConditionalAgentService builder(Class agentServiceClass, + DaprWorkflowClient workflowClient) { + return new DaprConditionalAgentService<>(agentServiceClass, workflowClient); + } +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/DaprLoopAgentService.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/DaprLoopAgentService.java new file mode 100644 index 000000000..17446787e --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/DaprLoopAgentService.java @@ -0,0 +1,158 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.workflow; + +import dev.langchain4j.agentic.UntypedAgent; +import dev.langchain4j.agentic.declarative.LoopAgent; +import dev.langchain4j.agentic.internal.AgentUtil; +import dev.langchain4j.agentic.planner.AgenticSystemTopology; +import dev.langchain4j.agentic.scope.AgenticScope; +import dev.langchain4j.agentic.workflow.impl.LoopAgentServiceImpl; +import io.dapr.workflows.client.DaprWorkflowClient; +import io.quarkiverse.dapr.langchain4j.workflow.orchestration.LoopOrchestrationWorkflow; + +import java.lang.reflect.Method; +import java.util.function.BiPredicate; +import java.util.function.Predicate; + +/** + * Loop agent service backed by a Dapr Workflow. + * Extends {@link LoopAgentServiceImpl} and implements {@link DaprAgentService} + * to provide Dapr-based loop orchestration with configurable exit conditions. + */ +public class DaprLoopAgentService extends LoopAgentServiceImpl implements DaprAgentService { + + private final DaprWorkflowClient workflowClient; + private int daprMaxIterations = Integer.MAX_VALUE; + private BiPredicate daprExitCondition; + private boolean daprTestExitAtLoopEnd; + + /** + * Constructs a new DaprLoopAgentService. + * + * @param agentServiceClass the agent service class + * @param workflowClient the Dapr workflow client + */ + public DaprLoopAgentService(Class agentServiceClass, DaprWorkflowClient workflowClient) { + super(agentServiceClass, resolveMethod(agentServiceClass)); + this.workflowClient = workflowClient; + } + + private static Method resolveMethod(Class agentServiceClass) { + if (agentServiceClass == UntypedAgent.class) { + return null; + } + return AgentUtil.validateAgentClass(agentServiceClass, false, LoopAgent.class); + } + + @Override + public String workflowType() { + return LoopOrchestrationWorkflow.class.getCanonicalName(); + } + + @Override + public DaprLoopAgentService maxIterations(int maxIterations) { + this.daprMaxIterations = maxIterations; + super.maxIterations(maxIterations); + return this; + } + + @Override + public DaprLoopAgentService exitCondition(Predicate exitCondition) { + this.daprExitCondition = (scope, iter) -> exitCondition.test(scope); + super.exitCondition(exitCondition); + return this; + } + + @Override + public DaprLoopAgentService exitCondition(BiPredicate exitCondition) { + this.daprExitCondition = exitCondition; + super.exitCondition(exitCondition); + return this; + } + + /** + * Sets the exit condition with a description. + * + * @param description the description + * @param exitCondition the exit condition predicate + * @return this builder + */ + @Override + public DaprLoopAgentService exitCondition(String description, Predicate exitCondition) { + this.daprExitCondition = (scope, iter) -> exitCondition.test(scope); + super.exitCondition(description, exitCondition); + return this; + } + + /** + * Sets the exit condition with a description and iteration count. + * + * @param description the description + * @param exitCondition the exit condition bi-predicate + * @return this builder + */ + @Override + public DaprLoopAgentService exitCondition( + String description, BiPredicate exitCondition) { + this.daprExitCondition = exitCondition; + super.exitCondition(description, exitCondition); + return this; + } + + @Override + public DaprLoopAgentService testExitAtLoopEnd(boolean testExitAtLoopEnd) { + this.daprTestExitAtLoopEnd = testExitAtLoopEnd; + super.testExitAtLoopEnd(testExitAtLoopEnd); + return this; + } + + @Override + public T build() { + return build(() -> { + DaprWorkflowPlanner planner = new DaprWorkflowPlanner( + LoopOrchestrationWorkflow.class, + "Loop", + AgenticSystemTopology.LOOP, + workflowClient); + planner.setMaxIterations(daprMaxIterations); + planner.setExitCondition(daprExitCondition); + planner.setTestExitAtLoopEnd(daprTestExitAtLoopEnd); + return planner; + }); + } + + /** + * Creates a builder for an untyped agent. + * + * @param workflowClient the Dapr workflow client + * @return a new builder instance + */ + public static DaprLoopAgentService builder(DaprWorkflowClient workflowClient) { + return new DaprLoopAgentService<>(UntypedAgent.class, workflowClient); + } + + /** + * Creates a builder for a typed agent service. + * + * @param agentServiceClass the agent service class + * @param workflowClient the Dapr workflow client + * @param the agent service type + * @return a new builder instance + */ + public static DaprLoopAgentService builder(Class agentServiceClass, + DaprWorkflowClient workflowClient) { + return new DaprLoopAgentService<>(agentServiceClass, workflowClient); + } +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/DaprParallelAgentService.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/DaprParallelAgentService.java new file mode 100644 index 000000000..3fa2d428e --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/DaprParallelAgentService.java @@ -0,0 +1,88 @@ +/* + * Copyright 2025 The Dapr 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.quarkiverse.dapr.langchain4j.workflow; + +import dev.langchain4j.agentic.UntypedAgent; +import dev.langchain4j.agentic.declarative.ParallelAgent; +import dev.langchain4j.agentic.internal.AgentUtil; +import dev.langchain4j.agentic.planner.AgenticSystemTopology; +import dev.langchain4j.agentic.workflow.ParallelAgentService; +import dev.langchain4j.agentic.workflow.impl.ParallelAgentServiceImpl; +import io.dapr.workflows.client.DaprWorkflowClient; +import io.quarkiverse.dapr.langchain4j.workflow.orchestration.ParallelOrchestrationWorkflow; + +/** + * Parallel agent service backed by a Dapr Workflow. + * Extends {@link ParallelAgentServiceImpl} and implements {@link DaprAgentService} + * to provide Dapr-based parallel orchestration. + */ +public class DaprParallelAgentService extends ParallelAgentServiceImpl implements DaprAgentService { + + private final DaprWorkflowClient workflowClient; + + /** + * Creates a new DaprParallelAgentService. + * + * @param agentServiceClass the agent service class + * @param workflowClient the Dapr workflow client + */ + public DaprParallelAgentService(Class agentServiceClass, DaprWorkflowClient workflowClient) { + super(agentServiceClass, resolveMethod(agentServiceClass)); + this.workflowClient = workflowClient; + } + + private static java.lang.reflect.Method resolveMethod(Class agentServiceClass) { + if (agentServiceClass == UntypedAgent.class) { + return null; + } + return AgentUtil.validateAgentClass(agentServiceClass, false, ParallelAgent.class); + } + + @Override + public String workflowType() { + return ParallelOrchestrationWorkflow.class.getCanonicalName(); + } + + @Override + public T build() { + return build(() -> new DaprWorkflowPlanner( + ParallelOrchestrationWorkflow.class, + "Parallel", + AgenticSystemTopology.PARALLEL, + workflowClient)); + } + + /** + * Creates a builder for untyped agents. + * + * @param workflowClient the Dapr workflow client + * @return a new DaprParallelAgentService instance + */ + public static DaprParallelAgentService builder(DaprWorkflowClient workflowClient) { + return new DaprParallelAgentService<>(UntypedAgent.class, workflowClient); + } + + /** + * Creates a builder for typed agents. + * + * @param agentServiceClass the agent service class + * @param workflowClient the Dapr workflow client + * @param the agent service type + * @return a new DaprParallelAgentService instance + */ + public static DaprParallelAgentService builder(Class agentServiceClass, + DaprWorkflowClient workflowClient) { + return new DaprParallelAgentService<>(agentServiceClass, workflowClient); + } +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/DaprPlannerRegistry.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/DaprPlannerRegistry.java new file mode 100644 index 000000000..a2ac21228 --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/DaprPlannerRegistry.java @@ -0,0 +1,64 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.workflow; + +import java.util.concurrent.ConcurrentHashMap; + +/** + * Static registry mapping planner IDs to {@link DaprWorkflowPlanner} instances. + * Allows Dapr WorkflowActivities (which are instantiated by the Dapr SDK) to + * look up the in-process planner. + */ +public class DaprPlannerRegistry { + + private static final ConcurrentHashMap registry = new ConcurrentHashMap<>(); + + /** + * Registers a planner with the given ID. + * + * @param id the planner ID + * @param planner the planner instance to register + */ + public static void register(String id, DaprWorkflowPlanner planner) { + registry.put(id, planner); + } + + /** + * Returns the planner for the given ID. + * + * @param id the planner ID + * @return the planner instance, or {@code null} if not registered + */ + public static DaprWorkflowPlanner get(String id) { + return registry.get(id); + } + + /** + * Unregisters the planner for the given ID. + * + * @param id the planner ID to unregister + */ + public static void unregister(String id) { + registry.remove(id); + } + + /** + * Returns the set of all registered planner IDs as a string. + * + * @return a string representation of the registered planner IDs + */ + public static String getRegisteredIds() { + return registry.keySet().toString(); + } +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/DaprSequentialAgentService.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/DaprSequentialAgentService.java new file mode 100644 index 000000000..545c0c7da --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/DaprSequentialAgentService.java @@ -0,0 +1,88 @@ +/* + * Copyright 2025 The Dapr 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.quarkiverse.dapr.langchain4j.workflow; + +import dev.langchain4j.agentic.UntypedAgent; +import dev.langchain4j.agentic.declarative.SequenceAgent; +import dev.langchain4j.agentic.internal.AgentUtil; +import dev.langchain4j.agentic.planner.AgenticSystemTopology; +import dev.langchain4j.agentic.workflow.SequentialAgentService; +import dev.langchain4j.agentic.workflow.impl.SequentialAgentServiceImpl; +import io.dapr.workflows.client.DaprWorkflowClient; +import io.quarkiverse.dapr.langchain4j.workflow.orchestration.SequentialOrchestrationWorkflow; + +/** + * Sequential agent service backed by a Dapr Workflow. + * Extends {@link SequentialAgentServiceImpl} and implements {@link DaprAgentService} + * to provide Dapr-based sequential orchestration. + */ +public class DaprSequentialAgentService extends SequentialAgentServiceImpl implements DaprAgentService { + + private final DaprWorkflowClient workflowClient; + + /** + * Creates a new DaprSequentialAgentService. + * + * @param agentServiceClass the agent service class + * @param workflowClient the Dapr workflow client + */ + public DaprSequentialAgentService(Class agentServiceClass, DaprWorkflowClient workflowClient) { + super(agentServiceClass, resolveMethod(agentServiceClass)); + this.workflowClient = workflowClient; + } + + private static java.lang.reflect.Method resolveMethod(Class agentServiceClass) { + if (agentServiceClass == UntypedAgent.class) { + return null; + } + return AgentUtil.validateAgentClass(agentServiceClass, false, SequenceAgent.class); + } + + @Override + public String workflowType() { + return SequentialOrchestrationWorkflow.class.getCanonicalName(); + } + + @Override + public T build() { + return build(() -> new DaprWorkflowPlanner( + SequentialOrchestrationWorkflow.class, + "Sequential", + AgenticSystemTopology.SEQUENCE, + workflowClient)); + } + + /** + * Creates a builder for untyped agents. + * + * @param workflowClient the Dapr workflow client + * @return a new DaprSequentialAgentService instance + */ + public static DaprSequentialAgentService builder(DaprWorkflowClient workflowClient) { + return new DaprSequentialAgentService<>(UntypedAgent.class, workflowClient); + } + + /** + * Creates a builder for typed agents. + * + * @param agentServiceClass the agent service class + * @param workflowClient the Dapr workflow client + * @param the agent service type + * @return a new DaprSequentialAgentService instance + */ + public static DaprSequentialAgentService builder(Class agentServiceClass, + DaprWorkflowClient workflowClient) { + return new DaprSequentialAgentService<>(agentServiceClass, workflowClient); + } +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/DaprWorkflowAgentsBuilder.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/DaprWorkflowAgentsBuilder.java new file mode 100644 index 000000000..6309bbd3e --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/DaprWorkflowAgentsBuilder.java @@ -0,0 +1,82 @@ +/* + * Copyright 2025 The Dapr 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.quarkiverse.dapr.langchain4j.workflow; + +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; +import io.dapr.workflows.client.DaprWorkflowClient; +import jakarta.enterprise.inject.spi.CDI; + +/** + * Dapr Workflow-backed implementation of {@link WorkflowAgentsBuilder}. + * Discovered via Java SPI to provide Dapr-based agent service builders + * for {@code @SequenceAgent}, {@code @ParallelAgent}, etc. + * + *

Obtains the {@link DaprWorkflowClient} from CDI to pass to each builder. + */ +public class DaprWorkflowAgentsBuilder implements WorkflowAgentsBuilder { + + /** + * Retrieves the DaprWorkflowClient from CDI. + * + * @return the workflow client + */ + private DaprWorkflowClient getWorkflowClient() { + return CDI.current().select(DaprWorkflowClient.class).get(); + } + + @Override + public SequentialAgentService sequenceBuilder() { + return DaprSequentialAgentService.builder(getWorkflowClient()); + } + + @Override + public SequentialAgentService sequenceBuilder(Class agentServiceClass) { + return DaprSequentialAgentService.builder(agentServiceClass, getWorkflowClient()); + } + + @Override + public ParallelAgentService parallelBuilder() { + return DaprParallelAgentService.builder(getWorkflowClient()); + } + + @Override + public ParallelAgentService parallelBuilder(Class agentServiceClass) { + return DaprParallelAgentService.builder(agentServiceClass, getWorkflowClient()); + } + + @Override + public LoopAgentService loopBuilder() { + return DaprLoopAgentService.builder(getWorkflowClient()); + } + + @Override + public LoopAgentService loopBuilder(Class agentServiceClass) { + return DaprLoopAgentService.builder(agentServiceClass, getWorkflowClient()); + } + + @Override + public ConditionalAgentService conditionalBuilder() { + return DaprConditionalAgentService.builder(getWorkflowClient()); + } + + @Override + public ConditionalAgentService conditionalBuilder(Class agentServiceClass) { + return DaprConditionalAgentService.builder(agentServiceClass, getWorkflowClient()); + } +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/DaprWorkflowPlanner.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/DaprWorkflowPlanner.java new file mode 100644 index 000000000..fc1b1a47f --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/DaprWorkflowPlanner.java @@ -0,0 +1,448 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.workflow; + +import dev.langchain4j.agentic.Agent; +import dev.langchain4j.agentic.planner.Action; +import dev.langchain4j.agentic.planner.AgentInstance; +import dev.langchain4j.agentic.planner.AgenticSystemTopology; +import dev.langchain4j.agentic.planner.InitPlanningContext; +import dev.langchain4j.agentic.planner.Planner; +import dev.langchain4j.agentic.planner.PlanningContext; +import dev.langchain4j.agentic.scope.AgenticScope; +import dev.langchain4j.service.SystemMessage; +import dev.langchain4j.service.UserMessage; +import io.dapr.workflows.Workflow; +import io.dapr.workflows.client.DaprWorkflowClient; +import io.quarkiverse.dapr.langchain4j.agent.DaprAgentContextHolder; +import io.quarkiverse.dapr.langchain4j.agent.DaprAgentRunRegistry; +import io.quarkiverse.dapr.langchain4j.agent.workflow.AgentEvent; +import io.quarkiverse.dapr.langchain4j.workflow.orchestration.OrchestrationInput; +import org.jboss.logging.Logger; + +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.UUID; +import java.util.concurrent.BlockingQueue; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ConcurrentLinkedDeque; +import java.util.concurrent.LinkedBlockingQueue; +import java.util.concurrent.locks.ReentrantLock; +import java.util.function.BiPredicate; +import java.util.function.Predicate; + +/** + * Core planner that bridges Langchain4j's agentic {@link Planner} framework with + * Dapr Workflows. Uses a lockstep synchronization pattern (BlockingQueue + CompletableFuture) + * to coordinate between Dapr Workflow execution and Langchain4j's agent planning loop. + */ +public class DaprWorkflowPlanner implements Planner { + + private static final Logger LOG = Logger.getLogger(DaprWorkflowPlanner.class); + + /** + * Metadata extracted from an {@link AgentInstance} for propagation to + * the per-agent {@link io.quarkiverse.dapr.langchain4j.agent.workflow.AgentRunWorkflow}. + * + * @param agentName human-readable name from {@code @Agent(name)} or the instance name + * @param userMessage the {@code @UserMessage} template text, or {@code null} if not annotated + * @param systemMessage the {@code @SystemMessage} template text, or {@code null} if not annotated + */ + public record AgentMetadata(String agentName, String userMessage, String systemMessage) { + } + + /** + * Exchange record used for thread synchronization between the Dapr Workflow + * thread (via activities) and the Langchain4j planner thread. + * A null agent signals workflow completion (sentinel). + * The {@code agentRunId} is forwarded to the planner so it can set + * {@link DaprAgentContextHolder} on the executing thread before tool calls begin. + */ + @SuppressWarnings({"EI_EXPOSE_REP", "EI_EXPOSE_REP2"}) + public record AgentExchange(AgentInstance agent, CompletableFuture continuation, String agentRunId) { + } + + /** + * Tracks per-agent completion info so {@link #nextAction} can signal the + * orchestration workflow and clean up after each agent finishes. + */ + private record PendingAgentInfo(String agentRunId) { + } + + private final String plannerId; + private final Class workflowClass; + private final String description; + private final AgenticSystemTopology topology; + private final DaprWorkflowClient workflowClient; + + private final BlockingQueue agentExchangeQueue = new LinkedBlockingQueue<>(); + private final ReentrantLock batchLock = new ReentrantLock(); + private volatile boolean workflowDone = false; + + private List agents = Collections.emptyList(); + private AgenticScope agenticScope; + + // Loop configuration + private int maxIterations = Integer.MAX_VALUE; + private BiPredicate exitCondition; + private boolean testExitAtLoopEnd; + + // Conditional configuration + private Map> conditions = Collections.emptyMap(); + + // Thread-safe deque for parallel agent futures — nextAction() is called from + // different threads (one per agent) in LangChain4j's parallel executor. + private final ConcurrentLinkedDeque> pendingFutures = new ConcurrentLinkedDeque<>(); + + // Thread-safe deque for per-agent completion info — polled in nextAction() + // alongside pendingFutures to signal the orchestration workflow and clean up. + private final ConcurrentLinkedDeque pendingAgentInfos = new ConcurrentLinkedDeque<>(); + + /** + * Creates a new DaprWorkflowPlanner. + * + * @param workflowClass the Dapr workflow class to schedule + * @param description a human-readable description + * @param topology the agentic system topology + * @param workflowClient the Dapr workflow client + */ + public DaprWorkflowPlanner(Class workflowClass, String description, + AgenticSystemTopology topology, DaprWorkflowClient workflowClient) { + this.plannerId = UUID.randomUUID().toString(); + this.workflowClass = workflowClass; + this.description = description; + this.topology = topology; + this.workflowClient = workflowClient; + } + + @Override + public AgenticSystemTopology topology() { + return topology; + } + + @Override + public void init(InitPlanningContext initPlanningContext) { + this.agents = new ArrayList<>(initPlanningContext.subagents()); + this.agenticScope = initPlanningContext.agenticScope(); + DaprPlannerRegistry.register(plannerId, this); + } + + @Override + public Action firstAction(PlanningContext planningContext) { + OrchestrationInput input = new OrchestrationInput( + plannerId, + agents.size(), + maxIterations, + testExitAtLoopEnd); + + workflowClient.scheduleNewWorkflow( + WorkflowNameResolver.resolve(workflowClass), input, plannerId); + return internalNextAction(); + } + + @Override + public Action nextAction(PlanningContext planningContext) { + // Clear the per-agent Dapr context now that the previous agent has finished. + DaprAgentContextHolder.clear(); + // Complete one future per call. LangChain4j calls nextAction() once per agent + // from separate threads in parallel execution. + CompletableFuture future = pendingFutures.poll(); + if (future != null) { + future.complete(null); + } + + // Signal the orchestration workflow that this agent completed and clean up. + PendingAgentInfo info = pendingAgentInfos.poll(); + if (info != null) { + try { + // Send "done" to the per-agent AgentRunWorkflow + workflowClient.raiseEvent(info.agentRunId(), "agent-event", + new AgentEvent("done", null, null, null)); + LOG.infof("[Planner:%s] Sent done event to AgentRunWorkflow — agentRunId=%s", + plannerId, info.agentRunId()); + DaprAgentRunRegistry.unregister(info.agentRunId()); + // Signal the orchestration workflow that this agent has completed + workflowClient.raiseEvent(plannerId, "agent-complete-" + info.agentRunId(), null); + LOG.infof("[Planner:%s] Raised agent-complete event — agentRunId=%s", + plannerId, info.agentRunId()); + } catch (Exception ex) { + LOG.warnf("[Planner:%s] Failed to signal agent completion for agentRunId=%s: %s", + plannerId, info.agentRunId(), ex.getMessage()); + } + } + + return internalNextAction(); + } + + /** + * Core synchronization: drains the agent exchange queue and batches + * agent calls for Langchain4j to execute. + * + *

Uses a {@link ReentrantLock} so that exactly one thread blocks on the exchange + * queue while other threads (from LangChain4j's parallel executor) return + * {@code done()} immediately. LangChain4j's {@code composeActions()} correctly + * merges {@code done() + call(batch) → call(batch)} and + * {@code done() + done() → done()}, so the composed result is always correct. + * + *

For sequential (single-agent) batches, sets {@link DaprAgentContextHolder} so that + * {@link io.quarkiverse.dapr.langchain4j.agent.DaprToolCallInterceptor} can route any + * {@code @Tool} calls made by the agent through the corresponding + * {@link io.quarkiverse.dapr.langchain4j.agent.workflow.AgentRunWorkflow}. + */ + private Action internalNextAction() { + if (workflowDone) { + return done(); + } + + // Only one thread should block waiting for the next batch. + // Other threads return done() — LangChain4j's composeActions() ensures + // done() + call(batch) → call(batch), so the batch is not lost. + if (!batchLock.tryLock()) { + return done(); + } + + try { + if (workflowDone) { + return done(); + } + + // Drain all queued agent exchanges + List exchanges = new ArrayList<>(); + try { + // Block for the first one + LOG.debugf("[Planner:%s] Waiting for agent exchanges on queue...", plannerId); + AgentExchange first = agentExchangeQueue.take(); + exchanges.add(first); + // Drain any additional ones that arrived + agentExchangeQueue.drainTo(exchanges); + } catch (InterruptedException ex) { + Thread.currentThread().interrupt(); + workflowDone = true; + cleanup(); + return done(); + } + + // Check for sentinel (null agent = workflow completed) + List batch = new ArrayList<>(); + for (AgentExchange exchange : exchanges) { + if (exchange.agent() == null) { + workflowDone = true; + cleanup(); + return done(); + } + batch.add(exchange.agent()); + } + + if (batch.isEmpty()) { + workflowDone = true; + cleanup(); + return done(); + } + + // Store all futures — one per agent. nextAction() is called once per agent + // (possibly from different threads), each call polls and completes one future. + pendingFutures.clear(); + pendingAgentInfos.clear(); + for (AgentExchange exchange : exchanges) { + pendingFutures.add(exchange.continuation()); + pendingAgentInfos.add(new PendingAgentInfo(exchange.agentRunId())); + } + + // For sequential execution (single agent), set the Dapr agent context so that + // DaprToolCallInterceptor can route @Tool calls through the AgentRunWorkflow. + if (exchanges.size() == 1 && exchanges.get(0).agentRunId() != null) { + DaprAgentContextHolder.set(exchanges.get(0).agentRunId()); + } + + return call(batch); + } finally { + batchLock.unlock(); + } + } + + /** + * Called by {@link io.quarkiverse.dapr.langchain4j.workflow.orchestration.activities.AgentExecutionActivity} + * to submit an agent for execution and wait for completion. + * + * @param agent the agent to execute + * @param agentRunId unique ID for this agent's per-run Dapr Workflow; forwarded to the + * planner so it can set {@link DaprAgentContextHolder} on the executing thread + * @return a future that completes when the planner has processed this agent + */ + public CompletableFuture executeAgent(AgentInstance agent, String agentRunId) { + CompletableFuture future = new CompletableFuture<>(); + agentExchangeQueue.add(new AgentExchange(agent, future, agentRunId)); + return future; + } + + /** + * Signals workflow completion by posting a sentinel to the queue. + */ + public void signalWorkflowComplete() { + LOG.infof("[Planner:%s] signalWorkflowComplete() — posting sentinel to queue", plannerId); + agentExchangeQueue.add(new AgentExchange(null, null, null)); + } + + /** + * Returns the agent at the given index. + * + * @param index the agent index + * @return the agent instance + */ + public AgentInstance getAgent(int index) { + return agents.get(index); + } + + /** + * Extracts metadata (name, user message template, system message template) from + * the {@link AgentInstance} at the given index. + * + *

The system and user message templates are extracted via reflection on the + * {@code @Agent}-annotated methods of {@link AgentInstance#type()}. If no annotated + * method is found, or the agent type is not reflectable, the messages will be {@code null}. + * + * @param index the index of the agent + * @return the agent metadata + */ + public AgentMetadata getAgentMetadata(int index) { + AgentInstance agent = agents.get(index); + String agentName = agent.name(); + String um = null; + String sm = null; + + try { + Class agentType = agent.type(); + if (agentType != null) { + for (Method method : agentType.getMethods()) { + if (method.isAnnotationPresent(Agent.class)) { + UserMessage userAnnotation = method.getAnnotation(UserMessage.class); + if (userAnnotation != null && userAnnotation.value().length > 0) { + um = String.join("\n", userAnnotation.value()); + } + SystemMessage systemAnnotation = method.getAnnotation(SystemMessage.class); + if (systemAnnotation != null && systemAnnotation.value().length > 0) { + sm = String.join("\n", systemAnnotation.value()); + } + break; + } + } + } + } catch (Exception ex) { + LOG.debugf("Could not extract prompt metadata from agent type for agent=%s: %s", + agentName, ex.getMessage()); + } + + return new AgentMetadata(agentName, um, sm); + } + + /** + * Returns the agentic scope. + * + * @return the agentic scope + */ + @SuppressWarnings("EI_EXPOSE_REP") + public AgenticScope getAgenticScope() { + return agenticScope; + } + + /** + * Evaluates the exit condition for loop workflows. + * + * @param iteration the current iteration number + * @return true if the loop should exit + */ + public boolean checkExitCondition(int iteration) { + if (exitCondition == null) { + return false; + } + return exitCondition.test(agenticScope, iteration); + } + + /** + * Evaluates whether a conditional agent should execute. + * + * @param agentIndex the index of the agent + * @return true if the agent should execute + */ + public boolean checkCondition(int agentIndex) { + if (conditions == null || !conditions.containsKey(agentIndex)) { + return true; // no condition means always execute + } + return conditions.get(agentIndex).test(agenticScope); + } + + /** + * Returns the planner ID. + * + * @return the planner ID + */ + public String getPlannerId() { + return plannerId; + } + + /** + * Returns the number of agents. + * + * @return the number of agents + */ + public int getAgentCount() { + return agents.size(); + } + + // Configuration setters (called by agent service builders) + + /** + * Sets the maximum number of iterations. + * + * @param maxIterations the max iterations + */ + public void setMaxIterations(int maxIterations) { + this.maxIterations = maxIterations; + } + + /** + * Sets the exit condition predicate. + * + * @param exitCondition the exit condition + */ + public void setExitCondition(BiPredicate exitCondition) { + this.exitCondition = exitCondition; + } + + /** + * Sets whether to test the exit condition at loop end. + * + * @param testExitAtLoopEnd true to test at loop end + */ + public void setTestExitAtLoopEnd(boolean testExitAtLoopEnd) { + this.testExitAtLoopEnd = testExitAtLoopEnd; + } + + /** + * Sets the conditions map for conditional agents. + * + * @param conditions the conditions map + */ + public void setConditions(Map> conditions) { + this.conditions = conditions == null ? Collections.emptyMap() : Map.copyOf(conditions); + } + + private void cleanup() { + DaprAgentContextHolder.clear(); + DaprPlannerRegistry.unregister(plannerId); + } +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/WorkflowNameResolver.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/WorkflowNameResolver.java new file mode 100644 index 000000000..f9ac42bd5 --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/WorkflowNameResolver.java @@ -0,0 +1,42 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.workflow; + +import io.dapr.workflows.Workflow; +import io.quarkiverse.dapr.workflows.WorkflowMetadata; + +/** + * Resolves the registration name for a {@link Workflow} class. + * If the class is annotated with {@link WorkflowMetadata} and provides a non-empty + * {@code name}, that name is returned; otherwise, the fully-qualified class name is used. + */ +public final class WorkflowNameResolver { + + private WorkflowNameResolver() { + } + + /** + * Returns the Dapr registration name for the given workflow class. + * + * @param workflowClass the workflow class to resolve the name for + * @return the Dapr registration name + */ + public static String resolve(Class workflowClass) { + WorkflowMetadata meta = workflowClass.getAnnotation(WorkflowMetadata.class); + if (meta != null && !meta.name().isEmpty()) { + return meta.name(); + } + return workflowClass.getCanonicalName(); + } +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/AgentExecInput.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/AgentExecInput.java new file mode 100644 index 000000000..37f78a82c --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/AgentExecInput.java @@ -0,0 +1,25 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.workflow.orchestration; + +/** + * Input for the AgentExecutionActivity. + * + * @param plannerId the planner ID to look up in the registry + * @param agentIndex the index of the agent in the planner's agent list + * @param agentRunId the unique ID for this agent execution, must match the child + * AgentRunWorkflow instance ID so raiseEvent() reaches the right workflow + */ +public record AgentExecInput(String plannerId, int agentIndex, String agentRunId) { +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/ConditionCheckInput.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/ConditionCheckInput.java new file mode 100644 index 000000000..841086927 --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/ConditionCheckInput.java @@ -0,0 +1,23 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.workflow.orchestration; + +/** + * Input for the ConditionCheckActivity (used by conditional workflows). + * + * @param plannerId the planner ID to look up in the registry + * @param agentIndex the index of the agent whose condition should be evaluated + */ +public record ConditionCheckInput(String plannerId, int agentIndex) { +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/ConditionalOrchestrationWorkflow.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/ConditionalOrchestrationWorkflow.java new file mode 100644 index 000000000..3ecc46987 --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/ConditionalOrchestrationWorkflow.java @@ -0,0 +1,67 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.workflow.orchestration; + +import io.dapr.workflows.Workflow; +import io.dapr.workflows.WorkflowStub; +import io.quarkiverse.dapr.langchain4j.agent.workflow.AgentRunInput; +import io.quarkiverse.dapr.langchain4j.workflow.DaprPlannerRegistry; +import io.quarkiverse.dapr.langchain4j.workflow.DaprWorkflowPlanner; +import io.quarkiverse.dapr.langchain4j.workflow.DaprWorkflowPlanner.AgentMetadata; +import io.quarkiverse.dapr.workflows.WorkflowMetadata; +import jakarta.enterprise.context.ApplicationScoped; + +/** + * Dapr Workflow that conditionally executes agents based on runtime predicates. + * For each agent, a condition check activity determines whether to execute it. + * Each agent is run as a child {@code AgentRunWorkflow} with a non-blocking bridging + * activity for planner coordination. Completion is detected via external events + * raised by {@link DaprWorkflowPlanner#nextAction}. + */ +@ApplicationScoped +@WorkflowMetadata(name = "conditional-agent") +public class ConditionalOrchestrationWorkflow implements Workflow { + + @Override + public WorkflowStub create() { + return ctx -> { + OrchestrationInput input = ctx.getInput(OrchestrationInput.class); + DaprWorkflowPlanner planner = DaprPlannerRegistry.get(input.plannerId()); + + for (int i = 0; i < input.agentCount(); i++) { + boolean shouldExec = ctx.callActivity("condition-check", + new ConditionCheckInput(input.plannerId(), i), + Boolean.class).await(); + if (shouldExec) { + String agentRunId = input.plannerId() + ":" + i; + AgentMetadata metadata = planner.getAgentMetadata(i); + AgentRunInput agentInput = new AgentRunInput(agentRunId, metadata.agentName(), + metadata.userMessage(), metadata.systemMessage()); + + var childWorkflow = ctx.callChildWorkflow("agent", agentInput, agentRunId, Void.class); + // Submit agent to planner (non-blocking activity — returns immediately) + ctx.callActivity("agent-call", + new AgentExecInput(input.plannerId(), i, agentRunId), Void.class).await(); + // Wait for agent completion (signaled by planner's nextAction) + ctx.waitForExternalEvent("agent-complete-" + agentRunId, Void.class).await(); + childWorkflow.await(); + } + } + // Signal planner that the workflow has completed + if (planner != null) { + planner.signalWorkflowComplete(); + } + }; + } +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/ExitConditionCheckInput.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/ExitConditionCheckInput.java new file mode 100644 index 000000000..d1ecac813 --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/ExitConditionCheckInput.java @@ -0,0 +1,23 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.workflow.orchestration; + +/** + * Input for the ExitConditionCheckActivity (used by loop workflows). + * + * @param plannerId the planner ID to look up in the registry + * @param iteration the current loop iteration number + */ +public record ExitConditionCheckInput(String plannerId, int iteration) { +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/LoopOrchestrationWorkflow.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/LoopOrchestrationWorkflow.java new file mode 100644 index 000000000..b88860c5f --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/LoopOrchestrationWorkflow.java @@ -0,0 +1,86 @@ +/* + * Copyright 2025 The Dapr 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.quarkiverse.dapr.langchain4j.workflow.orchestration; + +import io.dapr.workflows.Workflow; +import io.dapr.workflows.WorkflowStub; +import io.quarkiverse.dapr.langchain4j.agent.workflow.AgentRunInput; +import io.quarkiverse.dapr.langchain4j.workflow.DaprPlannerRegistry; +import io.quarkiverse.dapr.langchain4j.workflow.DaprWorkflowPlanner; +import io.quarkiverse.dapr.langchain4j.workflow.DaprWorkflowPlanner.AgentMetadata; +import io.quarkiverse.dapr.workflows.WorkflowMetadata; +import jakarta.enterprise.context.ApplicationScoped; + +/** + * Dapr Workflow that loops through agents repeatedly until an exit condition + * is met or the maximum number of iterations is reached. + * + *

Each agent is run as a child {@code AgentRunWorkflow} with a non-blocking bridging + * activity for planner coordination. Completion is detected via external events + * raised by {@link DaprWorkflowPlanner#nextAction}. + */ +@ApplicationScoped +@WorkflowMetadata(name = "loop-agent") +public class LoopOrchestrationWorkflow implements Workflow { + + @Override + public WorkflowStub create() { + return ctx -> { + OrchestrationInput input = ctx.getInput(OrchestrationInput.class); + DaprWorkflowPlanner planner = DaprPlannerRegistry.get(input.plannerId()); + + for (int iter = 0; iter < input.maxIterations(); iter++) { + // Check exit condition at loop start (unless configured to check at end) + if (!input.testExitAtLoopEnd()) { + boolean exit = ctx.callActivity("exit-condition-check", + new ExitConditionCheckInput(input.plannerId(), iter), + Boolean.class).await(); + if (exit) { + break; + } + } + + // Execute all agents sequentially within this iteration + for (int i = 0; i < input.agentCount(); i++) { + String agentRunId = input.plannerId() + ":" + iter + ":" + i; + AgentMetadata metadata = planner.getAgentMetadata(i); + AgentRunInput agentInput = new AgentRunInput(agentRunId, metadata.agentName(), + metadata.userMessage(), metadata.systemMessage()); + + var childWorkflow = ctx.callChildWorkflow("agent", agentInput, agentRunId, Void.class); + // Submit agent to planner (non-blocking activity -- returns immediately) + ctx.callActivity("agent-call", + new AgentExecInput(input.plannerId(), i, agentRunId), Void.class).await(); + // Wait for agent completion (signaled by planner's nextAction) + ctx.waitForExternalEvent("agent-complete-" + agentRunId, Void.class).await(); + childWorkflow.await(); + } + + // Check exit condition at loop end (if configured) + if (input.testExitAtLoopEnd()) { + boolean exit = ctx.callActivity("exit-condition-check", + new ExitConditionCheckInput(input.plannerId(), iter), + Boolean.class).await(); + if (exit) { + break; + } + } + } + // Signal planner that the workflow has completed + if (planner != null) { + planner.signalWorkflowComplete(); + } + }; + } +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/OrchestrationInput.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/OrchestrationInput.java new file mode 100644 index 000000000..d2e754e57 --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/OrchestrationInput.java @@ -0,0 +1,25 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.workflow.orchestration; + +/** + * Input data passed to all Dapr orchestration workflows. + * + * @param plannerId unique planner ID (used to look up the planner in the registry) + * @param agentCount number of sub-agents to execute + * @param maxIterations maximum loop iterations (only used by LoopOrchestrationWorkflow) + * @param testExitAtLoopEnd whether to test exit condition at loop end vs. loop start + */ +public record OrchestrationInput(String plannerId, int agentCount, int maxIterations, boolean testExitAtLoopEnd) { +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/ParallelOrchestrationWorkflow.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/ParallelOrchestrationWorkflow.java new file mode 100644 index 000000000..d2c4c8420 --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/ParallelOrchestrationWorkflow.java @@ -0,0 +1,76 @@ +/* + * Copyright 2025 The Dapr 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.quarkiverse.dapr.langchain4j.workflow.orchestration; + +import io.dapr.durabletask.Task; +import io.dapr.workflows.Workflow; +import io.dapr.workflows.WorkflowStub; +import io.quarkiverse.dapr.langchain4j.agent.workflow.AgentRunInput; +import io.quarkiverse.dapr.langchain4j.workflow.DaprPlannerRegistry; +import io.quarkiverse.dapr.langchain4j.workflow.DaprWorkflowPlanner; +import io.quarkiverse.dapr.langchain4j.workflow.DaprWorkflowPlanner.AgentMetadata; +import io.quarkiverse.dapr.workflows.WorkflowMetadata; +import jakarta.enterprise.context.ApplicationScoped; + +import java.util.ArrayList; +import java.util.List; + +/** + * Dapr Workflow that executes all agents in parallel and waits for all to complete. + * + *

Each agent is run as a child {@code AgentRunWorkflow} with a non-blocking bridging + * activity for planner coordination. Completion is detected via external events + * raised by {@link DaprWorkflowPlanner#nextAction}. + */ +@ApplicationScoped +@WorkflowMetadata(name = "parallel-agent") +public class ParallelOrchestrationWorkflow implements Workflow { + + @Override + public WorkflowStub create() { + return ctx -> { + OrchestrationInput input = ctx.getInput(OrchestrationInput.class); + DaprWorkflowPlanner planner = DaprPlannerRegistry.get(input.plannerId()); + + List> childWorkflows = new ArrayList<>(); + List> submitTasks = new ArrayList<>(); + List> completionEvents = new ArrayList<>(); + for (int i = 0; i < input.agentCount(); i++) { + String agentRunId = input.plannerId() + ":" + i; + AgentMetadata metadata = planner.getAgentMetadata(i); + AgentRunInput agentInput = new AgentRunInput(agentRunId, metadata.agentName(), + metadata.userMessage(), metadata.systemMessage()); + + // Start AgentRunWorkflow as a child workflow for proper nesting + childWorkflows.add(ctx.callChildWorkflow("agent", agentInput, agentRunId, Void.class)); + // Submit agent to planner (non-blocking activity -- returns immediately) + submitTasks.add(ctx.callActivity("agent-call", + new AgentExecInput(input.plannerId(), i, agentRunId), Void.class)); + // Register event listener for agent completion (signaled by planner's nextAction) + completionEvents.add( + ctx.waitForExternalEvent("agent-complete-" + agentRunId, Void.class)); + } + // Wait for all agents to be submitted + ctx.allOf(submitTasks).await(); + // Wait for all agents to complete (planner raises events after each agent finishes) + ctx.allOf(completionEvents).await(); + // Wait for all child AgentRunWorkflows to finish (they received "done" from planner) + ctx.allOf(childWorkflows).await(); + // Signal planner that the workflow has completed + if (planner != null) { + planner.signalWorkflowComplete(); + } + }; + } +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/SequentialOrchestrationWorkflow.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/SequentialOrchestrationWorkflow.java new file mode 100644 index 000000000..531535e61 --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/SequentialOrchestrationWorkflow.java @@ -0,0 +1,62 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.workflow.orchestration; + +import io.dapr.workflows.Workflow; +import io.dapr.workflows.WorkflowStub; +import io.quarkiverse.dapr.langchain4j.agent.workflow.AgentRunInput; +import io.quarkiverse.dapr.langchain4j.workflow.DaprPlannerRegistry; +import io.quarkiverse.dapr.langchain4j.workflow.DaprWorkflowPlanner; +import io.quarkiverse.dapr.langchain4j.workflow.DaprWorkflowPlanner.AgentMetadata; +import io.quarkiverse.dapr.workflows.WorkflowMetadata; +import jakarta.enterprise.context.ApplicationScoped; + +/** + * Dapr Workflow that executes agents sequentially, one after another. + * Each agent is run as a child {@code AgentRunWorkflow} with a non-blocking bridging + * activity for planner coordination. Completion is detected via external events + * raised by {@link DaprWorkflowPlanner#nextAction}. + */ +@ApplicationScoped +@WorkflowMetadata(name = "sequential-agent") +public class SequentialOrchestrationWorkflow implements Workflow { + + @Override + public WorkflowStub create() { + return ctx -> { + OrchestrationInput input = ctx.getInput(OrchestrationInput.class); + DaprWorkflowPlanner planner = DaprPlannerRegistry.get(input.plannerId()); + + for (int i = 0; i < input.agentCount(); i++) { + String agentRunId = input.plannerId() + ":" + i; + AgentMetadata metadata = planner.getAgentMetadata(i); + AgentRunInput agentInput = new AgentRunInput(agentRunId, metadata.agentName(), + metadata.userMessage(), metadata.systemMessage()); + + // Start AgentRunWorkflow as a child workflow for proper nesting + var childWorkflow = ctx.callChildWorkflow("agent", agentInput, agentRunId, Void.class); + // Submit agent to planner (non-blocking activity — returns immediately) + ctx.callActivity("agent-call", + new AgentExecInput(input.plannerId(), i, agentRunId), Void.class).await(); + // Wait for agent completion (signaled by planner's nextAction) + ctx.waitForExternalEvent("agent-complete-" + agentRunId, Void.class).await(); + childWorkflow.await(); + } + // Signal planner that the workflow has completed + if (planner != null) { + planner.signalWorkflowComplete(); + } + }; + } +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/activities/AgentExecutionActivity.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/activities/AgentExecutionActivity.java new file mode 100644 index 000000000..b01e9e221 --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/activities/AgentExecutionActivity.java @@ -0,0 +1,81 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.workflow.orchestration.activities; + +import io.dapr.workflows.WorkflowActivity; +import io.dapr.workflows.WorkflowActivityContext; +import io.quarkiverse.dapr.langchain4j.agent.AgentRunContext; +import io.quarkiverse.dapr.langchain4j.agent.DaprAgentRunRegistry; +import io.quarkiverse.dapr.langchain4j.workflow.DaprPlannerRegistry; +import io.quarkiverse.dapr.langchain4j.workflow.DaprWorkflowPlanner; +import io.quarkiverse.dapr.langchain4j.workflow.DaprWorkflowPlanner.AgentMetadata; +import io.quarkiverse.dapr.langchain4j.workflow.orchestration.AgentExecInput; +import io.quarkiverse.dapr.workflows.ActivityMetadata; +import jakarta.enterprise.context.ApplicationScoped; +import org.jboss.logging.Logger; +/** + * Dapr WorkflowActivity that bridges the Dapr Workflow execution to the + * LangChain4j planner. When invoked by an orchestration workflow alongside a + * child {@link io.quarkiverse.dapr.langchain4j.agent.workflow.AgentRunWorkflow}, it: + *

    + *
  1. Looks up the planner from the registry.
    2. + *
  2. Creates a per-agent {@link AgentRunContext} and registers it.
    3. + *
  3. Submits the agent to the planner's exchange queue (along with its {@code agentRunId}) + * so the planner can set {@link io.quarkiverse.dapr.langchain4j.agent.DaprAgentContextHolder} + * on the executing thread before tool calls begin.
    4. + *
  4. Returns immediately — the planner's {@code nextAction()} handles completion + * signaling (sending {@code "done"} to the AgentRunWorkflow, raising an external + * event to the orchestration workflow, and cleaning up the registry).
    5. + *
+ * + *

This activity is intentionally non-blocking to avoid exhausting the Dapr + * activity thread pool when composite agents (e.g., a {@code @SequenceAgent} nested + * inside a {@code @ParallelAgent}) spawn additional activities for their inner workflows. + */ + +@ApplicationScoped +@ActivityMetadata(name = "agent-call") +public class AgentExecutionActivity implements WorkflowActivity { + + private static final Logger LOG = Logger.getLogger(AgentExecutionActivity.class); + + @Override + public Object run(WorkflowActivityContext ctx) { + AgentExecInput input = ctx.getInput(AgentExecInput.class); + DaprWorkflowPlanner planner = DaprPlannerRegistry.get(input.plannerId()); + if (planner == null) { + throw new IllegalStateException("No planner found for ID: " + input.plannerId() + + ". Registered IDs: " + DaprPlannerRegistry.getRegisteredIds()); + } + + AgentMetadata metadata = planner.getAgentMetadata(input.agentIndex()); + String agentName = metadata.agentName(); + String agentRunId = input.agentRunId(); + + LOG.infof("[Planner:%s] AgentExecutionActivity started — agent=%s, agentRunId=%s", + input.plannerId(), agentName, agentRunId); + + AgentRunContext runContext = new AgentRunContext(agentRunId); + DaprAgentRunRegistry.register(agentRunId, runContext); + + // Submit the agent to the planner's exchange queue (non-blocking). + // The planner's nextAction() handles completion signaling and cleanup. + planner.executeAgent(planner.getAgent(input.agentIndex()), agentRunId); + + LOG.infof("[Planner:%s] AgentExecutionActivity submitted — agent=%s, agentRunId=%s", + input.plannerId(), agentName, agentRunId); + + return null; + } +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/activities/ConditionCheckActivity.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/activities/ConditionCheckActivity.java new file mode 100644 index 000000000..c377839e9 --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/activities/ConditionCheckActivity.java @@ -0,0 +1,41 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.workflow.orchestration.activities; + +import io.dapr.workflows.WorkflowActivity; +import io.dapr.workflows.WorkflowActivityContext; +import io.quarkiverse.dapr.langchain4j.workflow.DaprPlannerRegistry; +import io.quarkiverse.dapr.langchain4j.workflow.DaprWorkflowPlanner; +import io.quarkiverse.dapr.langchain4j.workflow.orchestration.ConditionCheckInput; +import io.quarkiverse.dapr.workflows.ActivityMetadata; +import jakarta.enterprise.context.ApplicationScoped; + +/** + * Dapr WorkflowActivity that checks whether a conditional agent should execute. + * Returns {@code true} if the agent's condition is met, {@code false} otherwise. + */ +@ApplicationScoped +@ActivityMetadata(name = "condition-check") +public class ConditionCheckActivity implements WorkflowActivity { + + @Override + public Object run(WorkflowActivityContext ctx) { + ConditionCheckInput input = ctx.getInput(ConditionCheckInput.class); + DaprWorkflowPlanner planner = DaprPlannerRegistry.get(input.plannerId()); + if (planner == null) { + throw new IllegalStateException("No planner found for ID: " + input.plannerId()); + } + return planner.checkCondition(input.agentIndex()); + } +} diff --git a/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/activities/ExitConditionCheckActivity.java b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/activities/ExitConditionCheckActivity.java new file mode 100644 index 000000000..7c65c3986 --- /dev/null +++ b/quarkus/runtime/src/main/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/activities/ExitConditionCheckActivity.java @@ -0,0 +1,41 @@ +/* + * Copyright 2026 The Dapr 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.quarkiverse.dapr.langchain4j.workflow.orchestration.activities; + +import io.dapr.workflows.WorkflowActivity; +import io.dapr.workflows.WorkflowActivityContext; +import io.quarkiverse.dapr.langchain4j.workflow.DaprPlannerRegistry; +import io.quarkiverse.dapr.langchain4j.workflow.DaprWorkflowPlanner; +import io.quarkiverse.dapr.langchain4j.workflow.orchestration.ExitConditionCheckInput; +import io.quarkiverse.dapr.workflows.ActivityMetadata; +import jakarta.enterprise.context.ApplicationScoped; + +/** + * Dapr WorkflowActivity that checks the exit condition for loop workflows. + * Returns {@code true} if the loop should exit, {@code false} otherwise. + */ +@ApplicationScoped +@ActivityMetadata(name = "exit-condition-check") +public class ExitConditionCheckActivity implements WorkflowActivity { + + @Override + public Object run(WorkflowActivityContext ctx) { + ExitConditionCheckInput input = ctx.getInput(ExitConditionCheckInput.class); + DaprWorkflowPlanner planner = DaprPlannerRegistry.get(input.plannerId()); + if (planner == null) { + throw new IllegalStateException("No planner found for ID: " + input.plannerId()); + } + return planner.checkExitCondition(input.iteration()); + } +} diff --git a/quarkus/runtime/src/main/resources/META-INF/quarkus-extension.yaml b/quarkus/runtime/src/main/resources/META-INF/quarkus-extension.yaml new file mode 100644 index 000000000..5ef11eeba --- /dev/null +++ b/quarkus/runtime/src/main/resources/META-INF/quarkus-extension.yaml @@ -0,0 +1,11 @@ +name: Agentic Dapr +description: Agentic Dapr +artifact: ${project.groupId}:${project.artifactId}:${project.version} +metadata: + keywords: + - ai + - agentic + - cncf + - dapr + categories: + - "integration" \ No newline at end of file diff --git a/quarkus/runtime/src/main/resources/META-INF/services/dev.langchain4j.agentic.workflow.WorkflowAgentsBuilder b/quarkus/runtime/src/main/resources/META-INF/services/dev.langchain4j.agentic.workflow.WorkflowAgentsBuilder new file mode 100644 index 000000000..ba35d9f09 --- /dev/null +++ b/quarkus/runtime/src/main/resources/META-INF/services/dev.langchain4j.agentic.workflow.WorkflowAgentsBuilder @@ -0,0 +1 @@ +io.quarkiverse.dapr.langchain4j.workflow.DaprWorkflowAgentsBuilder \ No newline at end of file diff --git a/quarkus/runtime/src/test/java/io/quarkiverse/dapr/langchain4j/memory/KeyValueChatMemoryStoreTest.java b/quarkus/runtime/src/test/java/io/quarkiverse/dapr/langchain4j/memory/KeyValueChatMemoryStoreTest.java new file mode 100644 index 000000000..26ae43a11 --- /dev/null +++ b/quarkus/runtime/src/test/java/io/quarkiverse/dapr/langchain4j/memory/KeyValueChatMemoryStoreTest.java @@ -0,0 +1,195 @@ +package io.quarkiverse.dapr.langchain4j.memory; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import java.util.ArrayList; +import java.util.List; +import java.util.function.Function; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.ArgumentCaptor; + +import dev.langchain4j.data.message.AiMessage; +import dev.langchain4j.data.message.ChatMessage; +import dev.langchain4j.data.message.SystemMessage; +import dev.langchain4j.data.message.UserMessage; +import io.dapr.client.DaprClient; +import io.dapr.client.domain.State; +import reactor.core.publisher.Mono; + +class KeyValueChatMemoryStoreTest { + + private static final String STATE_STORE_NAME = "statestore"; + + private DaprClient daprClient; + private KeyValueChatMemoryStore store; + + /** + * Simple serializer for testing: stores the message type and text, one per line. + * Format: "TYPE:text\nTYPE:text\n..." + */ + private static final Function, String> TEST_SERIALIZER = messages -> { + StringBuilder sb = new StringBuilder(); + for (ChatMessage msg : messages) { + sb.append(msg.type().name()).append(":"); + switch (msg.type()) { + case SYSTEM -> sb.append(((SystemMessage) msg).text()); + case USER -> sb.append(((UserMessage) msg).singleText()); + case AI -> sb.append(((AiMessage) msg).text()); + default -> sb.append("unknown"); + } + sb.append("\n"); + } + return sb.toString(); + }; + + private static final Function> TEST_DESERIALIZER = json -> { + List messages = new ArrayList<>(); + for (String line : json.split("\n")) { + if (line.isEmpty()) + continue; + String[] parts = line.split(":", 2); + String type = parts[0]; + String text = parts[1]; + switch (type) { + case "SYSTEM" -> messages.add(new SystemMessage(text)); + case "USER" -> messages.add(new UserMessage(text)); + case "AI" -> messages.add(new AiMessage(text)); + } + } + return messages; + }; + + @BeforeEach + void setUp() { + daprClient = mock(DaprClient.class); + store = new KeyValueChatMemoryStore(daprClient, STATE_STORE_NAME, + TEST_SERIALIZER, TEST_DESERIALIZER); + } + + @Test + void getMessagesShouldReturnEmptyListWhenKeyDoesNotExist() { + State emptyState = new State<>("user-1", (String) null, (String) null); + when(daprClient.getState(eq(STATE_STORE_NAME), eq("user-1"), eq(String.class))) + .thenReturn(Mono.just(emptyState)); + + List messages = store.getMessages("user-1"); + + assertThat(messages).isEmpty(); + verify(daprClient).getState(STATE_STORE_NAME, "user-1", String.class); + } + + @Test + void getMessagesShouldReturnEmptyListWhenValueIsEmpty() { + State emptyState = new State<>("user-1", "", (String) null); + when(daprClient.getState(eq(STATE_STORE_NAME), eq("user-1"), eq(String.class))) + .thenReturn(Mono.just(emptyState)); + + List messages = store.getMessages("user-1"); + + assertThat(messages).isEmpty(); + } + + @Test + void updateMessagesShouldSaveSerializedMessages() { + when(daprClient.saveState(eq(STATE_STORE_NAME), eq("user-1"), any(String.class))) + .thenReturn(Mono.empty()); + + List messages = List.of( + new UserMessage("Hello"), + new AiMessage("Hi there!")); + + store.updateMessages("user-1", messages); + + ArgumentCaptor jsonCaptor = ArgumentCaptor.forClass(String.class); + verify(daprClient).saveState(eq(STATE_STORE_NAME), eq("user-1"), jsonCaptor.capture()); + + String savedJson = jsonCaptor.getValue(); + assertThat(savedJson).contains("USER:Hello"); + assertThat(savedJson).contains("AI:Hi there!"); + } + + @Test + void getMessagesShouldReturnDeserializedMessages() { + String stored = "SYSTEM:You are a helpful assistant\nUSER:What is Java?\nAI:A programming language.\n"; + State state = new State<>("conv-42", stored, (String) null); + when(daprClient.getState(eq(STATE_STORE_NAME), eq("conv-42"), eq(String.class))) + .thenReturn(Mono.just(state)); + + List retrieved = store.getMessages("conv-42"); + + assertThat(retrieved).hasSize(3); + assertThat(retrieved.get(0)).isInstanceOf(SystemMessage.class); + assertThat(((SystemMessage) retrieved.get(0)).text()).isEqualTo("You are a helpful assistant"); + assertThat(retrieved.get(1)).isInstanceOf(UserMessage.class); + assertThat(((UserMessage) retrieved.get(1)).singleText()).isEqualTo("What is Java?"); + assertThat(retrieved.get(2)).isInstanceOf(AiMessage.class); + assertThat(((AiMessage) retrieved.get(2)).text()).isEqualTo("A programming language."); + } + + @Test + void deleteMessagesShouldRemoveState() { + when(daprClient.deleteState(eq(STATE_STORE_NAME), eq("user-1"))) + .thenReturn(Mono.empty()); + + store.deleteMessages("user-1"); + + verify(daprClient).deleteState(STATE_STORE_NAME, "user-1"); + } + + @Test + void shouldUseMemoryIdToStringAsKey() { + when(daprClient.saveState(eq(STATE_STORE_NAME), eq("123"), any(String.class))) + .thenReturn(Mono.empty()); + + store.updateMessages(123, List.of(new UserMessage("test"))); + + verify(daprClient).saveState(eq(STATE_STORE_NAME), eq("123"), any(String.class)); + } + + @Test + void updateMessagesShouldHandleEmptyList() { + when(daprClient.saveState(eq(STATE_STORE_NAME), eq("user-1"), any(String.class))) + .thenReturn(Mono.empty()); + + store.updateMessages("user-1", List.of()); + + verify(daprClient).saveState(eq(STATE_STORE_NAME), eq("user-1"), any(String.class)); + } + + @Test + void roundTripShouldPreserveMessages() { + // Save messages + when(daprClient.saveState(eq(STATE_STORE_NAME), eq("rt-1"), any(String.class))) + .thenReturn(Mono.empty()); + + List original = List.of( + new SystemMessage("Be concise"), + new UserMessage("Hello"), + new AiMessage("Hi!")); + + store.updateMessages("rt-1", original); + + // Capture what was saved + ArgumentCaptor captor = ArgumentCaptor.forClass(String.class); + verify(daprClient).saveState(eq(STATE_STORE_NAME), eq("rt-1"), captor.capture()); + + // Now simulate reading it back + State state = new State<>("rt-1", captor.getValue(), (String) null); + when(daprClient.getState(eq(STATE_STORE_NAME), eq("rt-1"), eq(String.class))) + .thenReturn(Mono.just(state)); + + List retrieved = store.getMessages("rt-1"); + + assertThat(retrieved).hasSize(3); + assertThat(((SystemMessage) retrieved.get(0)).text()).isEqualTo("Be concise"); + assertThat(((UserMessage) retrieved.get(1)).singleText()).isEqualTo("Hello"); + assertThat(((AiMessage) retrieved.get(2)).text()).isEqualTo("Hi!"); + } +} diff --git a/quarkus/runtime/src/test/java/io/quarkiverse/dapr/langchain4j/workflow/DaprAgentServiceUtilTest.java b/quarkus/runtime/src/test/java/io/quarkiverse/dapr/langchain4j/workflow/DaprAgentServiceUtilTest.java new file mode 100644 index 000000000..8a5704afe --- /dev/null +++ b/quarkus/runtime/src/test/java/io/quarkiverse/dapr/langchain4j/workflow/DaprAgentServiceUtilTest.java @@ -0,0 +1,38 @@ +package io.quarkiverse.dapr.langchain4j.workflow; + +import static org.assertj.core.api.Assertions.assertThat; + +import org.junit.jupiter.api.Test; + +class DaprAgentServiceUtilTest { + + @Test + void shouldSanitizeName() { + assertThat(DaprAgentServiceUtil.safeName("hello-world_123")).isEqualTo("hello-world_123"); + } + + @Test + void shouldReplaceSpecialCharacters() { + assertThat(DaprAgentServiceUtil.safeName("my agent!@#$%")).isEqualTo("my_agent_____"); + } + + @Test + void shouldReplaceSpaces() { + assertThat(DaprAgentServiceUtil.safeName("agent name with spaces")).isEqualTo("agent_name_with_spaces"); + } + + @Test + void shouldHandleNullName() { + assertThat(DaprAgentServiceUtil.safeName(null)).isEqualTo("unnamed"); + } + + @Test + void shouldHandleEmptyName() { + assertThat(DaprAgentServiceUtil.safeName("")).isEqualTo("unnamed"); + } + + @Test + void shouldPreserveAlphanumericHyphenUnderscore() { + assertThat(DaprAgentServiceUtil.safeName("ABC-def_123")).isEqualTo("ABC-def_123"); + } +} diff --git a/quarkus/runtime/src/test/java/io/quarkiverse/dapr/langchain4j/workflow/DaprPlannerRegistryTest.java b/quarkus/runtime/src/test/java/io/quarkiverse/dapr/langchain4j/workflow/DaprPlannerRegistryTest.java new file mode 100644 index 000000000..1fb7df20d --- /dev/null +++ b/quarkus/runtime/src/test/java/io/quarkiverse/dapr/langchain4j/workflow/DaprPlannerRegistryTest.java @@ -0,0 +1,52 @@ +package io.quarkiverse.dapr.langchain4j.workflow; + +import static org.assertj.core.api.Assertions.assertThat; + +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.Test; + +import static org.mockito.Mockito.mock; + +import dev.langchain4j.agentic.planner.AgenticSystemTopology; +import io.dapr.workflows.client.DaprWorkflowClient; +import io.quarkiverse.dapr.langchain4j.workflow.orchestration.SequentialOrchestrationWorkflow; + +class DaprPlannerRegistryTest { + + @AfterEach + void cleanup() { + // Clean up any registered planners + DaprPlannerRegistry.unregister("test-id-1"); + DaprPlannerRegistry.unregister("test-id-2"); + } + + @Test + void shouldRegisterAndRetrievePlanner() { + DaprWorkflowClient client = mock(DaprWorkflowClient.class); + DaprWorkflowPlanner planner = new DaprWorkflowPlanner( + SequentialOrchestrationWorkflow.class, "test", AgenticSystemTopology.SEQUENCE, client); + + String id = planner.getPlannerId(); + DaprPlannerRegistry.register(id, planner); + + assertThat(DaprPlannerRegistry.get(id)).isSameAs(planner); + } + + @Test + void shouldReturnNullForUnknownId() { + assertThat(DaprPlannerRegistry.get("nonexistent")).isNull(); + } + + @Test + void shouldUnregisterPlanner() { + DaprWorkflowClient client = mock(DaprWorkflowClient.class); + DaprWorkflowPlanner planner = new DaprWorkflowPlanner( + SequentialOrchestrationWorkflow.class, "test", AgenticSystemTopology.SEQUENCE, client); + + String id = planner.getPlannerId(); + DaprPlannerRegistry.register(id, planner); + DaprPlannerRegistry.unregister(id); + + assertThat(DaprPlannerRegistry.get(id)).isNull(); + } +} diff --git a/quarkus/runtime/src/test/java/io/quarkiverse/dapr/langchain4j/workflow/DaprWorkflowAgentsBuilderTest.java b/quarkus/runtime/src/test/java/io/quarkiverse/dapr/langchain4j/workflow/DaprWorkflowAgentsBuilderTest.java new file mode 100644 index 000000000..a073c7038 --- /dev/null +++ b/quarkus/runtime/src/test/java/io/quarkiverse/dapr/langchain4j/workflow/DaprWorkflowAgentsBuilderTest.java @@ -0,0 +1,95 @@ +package io.quarkiverse.dapr.langchain4j.workflow; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.mock; + +import java.util.ServiceLoader; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +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; +import io.dapr.workflows.client.DaprWorkflowClient; + +class DaprWorkflowAgentsBuilderTest { + + private DaprWorkflowClient workflowClient; + + @BeforeEach + void setUp() { + workflowClient = mock(DaprWorkflowClient.class); + } + + @Test + void shouldBeDiscoverableViaSPI() { + ServiceLoader loader = ServiceLoader.load(WorkflowAgentsBuilder.class); + boolean found = false; + for (WorkflowAgentsBuilder builder : loader) { + if (builder instanceof DaprWorkflowAgentsBuilder) { + found = true; + break; + } + } + assertThat(found).as("DaprWorkflowAgentsBuilder should be discoverable via ServiceLoader").isTrue(); + } + + @Test + void sequenceBuilderShouldReturnDaprSequentialAgentService() { + SequentialAgentService service = DaprSequentialAgentService.builder(workflowClient); + assertThat(service).isInstanceOf(DaprSequentialAgentService.class); + } + + @Test + void typedSequenceBuilderShouldReturnDaprSequentialAgentService() { + SequentialAgentService service = DaprSequentialAgentService.builder(MyAgentService.class, + workflowClient); + assertThat(service).isInstanceOf(DaprSequentialAgentService.class); + } + + @Test + void parallelBuilderShouldReturnDaprParallelAgentService() { + ParallelAgentService service = DaprParallelAgentService.builder(workflowClient); + assertThat(service).isInstanceOf(DaprParallelAgentService.class); + } + + @Test + void typedParallelBuilderShouldReturnDaprParallelAgentService() { + ParallelAgentService service = DaprParallelAgentService.builder(MyAgentService.class, + workflowClient); + assertThat(service).isInstanceOf(DaprParallelAgentService.class); + } + + @Test + void loopBuilderShouldReturnDaprLoopAgentService() { + LoopAgentService service = DaprLoopAgentService.builder(workflowClient); + assertThat(service).isInstanceOf(DaprLoopAgentService.class); + } + + @Test + void typedLoopBuilderShouldReturnDaprLoopAgentService() { + LoopAgentService service = DaprLoopAgentService.builder(MyAgentService.class, workflowClient); + assertThat(service).isInstanceOf(DaprLoopAgentService.class); + } + + @Test + void conditionalBuilderShouldReturnDaprConditionalAgentService() { + ConditionalAgentService service = DaprConditionalAgentService.builder(workflowClient); + assertThat(service).isInstanceOf(DaprConditionalAgentService.class); + } + + @Test + void typedConditionalBuilderShouldReturnDaprConditionalAgentService() { + ConditionalAgentService service = DaprConditionalAgentService.builder(MyAgentService.class, + workflowClient); + assertThat(service).isInstanceOf(DaprConditionalAgentService.class); + } + + /** Dummy interface for typed builder tests. */ + interface MyAgentService { + } +} diff --git a/quarkus/runtime/src/test/java/io/quarkiverse/dapr/langchain4j/workflow/DaprWorkflowPlannerTest.java b/quarkus/runtime/src/test/java/io/quarkiverse/dapr/langchain4j/workflow/DaprWorkflowPlannerTest.java new file mode 100644 index 000000000..7734be103 --- /dev/null +++ b/quarkus/runtime/src/test/java/io/quarkiverse/dapr/langchain4j/workflow/DaprWorkflowPlannerTest.java @@ -0,0 +1,291 @@ +package io.quarkiverse.dapr.langchain4j.workflow; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import java.util.List; +import java.util.Map; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; +import java.util.function.Predicate; + +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import dev.langchain4j.agentic.Agent; +import dev.langchain4j.agentic.planner.Action; +import dev.langchain4j.agentic.planner.AgentInstance; +import dev.langchain4j.agentic.planner.AgenticSystemTopology; +import dev.langchain4j.agentic.planner.InitPlanningContext; +import dev.langchain4j.agentic.planner.PlanningContext; +import dev.langchain4j.agentic.scope.AgenticScope; +import dev.langchain4j.service.SystemMessage; +import dev.langchain4j.service.UserMessage; +import io.dapr.workflows.client.DaprWorkflowClient; +import io.quarkiverse.dapr.langchain4j.workflow.DaprWorkflowPlanner.AgentMetadata; +import io.quarkiverse.dapr.langchain4j.workflow.orchestration.SequentialOrchestrationWorkflow; + +class DaprWorkflowPlannerTest { + + private DaprWorkflowClient workflowClient; + private DaprWorkflowPlanner planner; + private AgentInstance agent1; + private AgentInstance agent2; + private AgenticScope scope; + + @BeforeEach + void setUp() { + workflowClient = mock(DaprWorkflowClient.class); + planner = new DaprWorkflowPlanner( + SequentialOrchestrationWorkflow.class, + "test", + AgenticSystemTopology.SEQUENCE, + workflowClient); + + agent1 = mock(AgentInstance.class); + when(agent1.name()).thenReturn("agent1"); + agent2 = mock(AgentInstance.class); + when(agent2.name()).thenReturn("agent2"); + scope = mock(AgenticScope.class); + } + + @AfterEach + void tearDown() { + DaprPlannerRegistry.unregister(planner.getPlannerId()); + } + + @Test + void shouldHaveUniqueId() { + DaprWorkflowPlanner planner2 = new DaprWorkflowPlanner( + SequentialOrchestrationWorkflow.class, "test2", AgenticSystemTopology.SEQUENCE, workflowClient); + assertThat(planner.getPlannerId()).isNotEqualTo(planner2.getPlannerId()); + } + + @Test + void shouldReturnCorrectTopology() { + assertThat(planner.topology()).isEqualTo(AgenticSystemTopology.SEQUENCE); + } + + @Test + void shouldRegisterInRegistryOnInit() { + InitPlanningContext ctx = new InitPlanningContext(scope, mock(AgentInstance.class), List.of(agent1, agent2)); + planner.init(ctx); + + assertThat(DaprPlannerRegistry.get(planner.getPlannerId())).isSameAs(planner); + } + + @Test + void shouldStoreAgentsOnInit() { + InitPlanningContext ctx = new InitPlanningContext(scope, mock(AgentInstance.class), List.of(agent1, agent2)); + planner.init(ctx); + + assertThat(planner.getAgent(0)).isSameAs(agent1); + assertThat(planner.getAgent(1)).isSameAs(agent2); + } + + @Test + void shouldScheduleWorkflowOnFirstAction() { + InitPlanningContext initCtx = new InitPlanningContext(scope, mock(AgentInstance.class), List.of(agent1)); + planner.init(initCtx); + + // Simulate workflow posting a completion sentinel immediately + Thread workflowThread = new Thread(() -> { + try { + Thread.sleep(50); + planner.signalWorkflowComplete(); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + } + }); + workflowThread.start(); + + PlanningContext planCtx = mock(PlanningContext.class); + Action action = planner.firstAction(planCtx); + + verify(workflowClient).scheduleNewWorkflow( + eq("sequential-agent"), + any(), + eq(planner.getPlannerId())); + + // Sentinel was posted, so the planner returns done() + assertThat(action.isDone()).isTrue(); + } + + @Test + void executeAgentShouldQueueAndReturnFuture() { + CompletableFuture future = planner.executeAgent(agent1, null); + assertThat(future).isNotNull(); + assertThat(future.isDone()).isFalse(); + + // Completing the future should work + future.complete(null); + assertThat(future.isDone()).isTrue(); + } + + @Test + void signalWorkflowCompleteShouldPostSentinel() throws Exception { + // Pre-load an agent exchange + a completion sentinel + planner.executeAgent(agent1, null); + planner.signalWorkflowComplete(); + + // The planner should be able to drain both: first the agent, then the sentinel + // We verify via internalNextAction indirectly through firstAction + InitPlanningContext initCtx = new InitPlanningContext(scope, mock(AgentInstance.class), List.of(agent1)); + planner.init(initCtx); + + // Skip firstAction's scheduleNewWorkflow - agent + sentinel already queued + // First drain returns the agent + // Second drain (via nextAction) returns done + + // This test verifies the sentinel mechanism works + assertThat(planner.getPlannerId()).isNotNull(); + } + + @Test + void shouldEvaluateExitConditionAsFalseWhenNull() { + assertThat(planner.checkExitCondition(0)).isFalse(); + } + + @Test + void shouldEvaluateExitCondition() { + InitPlanningContext initCtx = new InitPlanningContext(scope, mock(AgentInstance.class), List.of(agent1)); + planner.init(initCtx); + + planner.setExitCondition((s, iter) -> iter >= 3); + + assertThat(planner.checkExitCondition(0)).isFalse(); + assertThat(planner.checkExitCondition(2)).isFalse(); + assertThat(planner.checkExitCondition(3)).isTrue(); + assertThat(planner.checkExitCondition(5)).isTrue(); + } + + @Test + void shouldReturnTrueForConditionCheckWhenNoCondition() { + assertThat(planner.checkCondition(0)).isTrue(); + assertThat(planner.checkCondition(99)).isTrue(); + } + + @Test + void shouldEvaluateConditionCheck() { + InitPlanningContext initCtx = new InitPlanningContext(scope, mock(AgentInstance.class), List.of(agent1, agent2)); + planner.init(initCtx); + + Predicate alwaysTrue = s -> true; + Predicate alwaysFalse = s -> false; + planner.setConditions(Map.of(0, alwaysTrue, 1, alwaysFalse)); + + assertThat(planner.checkCondition(0)).isTrue(); + assertThat(planner.checkCondition(1)).isFalse(); + } + + @Test + void shouldHandleConcurrentExecuteAgentCalls() throws Exception { + CountDownLatch latch = new CountDownLatch(2); + + Thread t1 = new Thread(() -> { + planner.executeAgent(agent1, null); + latch.countDown(); + }); + Thread t2 = new Thread(() -> { + planner.executeAgent(agent2, null); + latch.countDown(); + }); + + t1.start(); + t2.start(); + + assertThat(latch.await(5, TimeUnit.SECONDS)).isTrue(); + } + + // --- Test interfaces for getAgentMetadata() --- + + interface AnnotatedAgent { + @Agent(name = "annotated") + @SystemMessage("You are a helpful assistant") + @UserMessage("Please help with: {{it}}") + String chat(String input); + } + + interface AgentWithoutMessages { + @Agent(name = "no-messages") + String chat(String input); + } + + interface AgentWithSystemOnly { + @Agent(name = "system-only") + @SystemMessage("System prompt here") + String chat(String input); + } + + // --- Tests for getAgentMetadata() --- + + @Test + void getAgentMetadataShouldExtractAnnotations() { + AgentInstance agent = mock(AgentInstance.class); + when(agent.name()).thenReturn("annotated"); + when(agent.type()).thenReturn((Class) AnnotatedAgent.class); + + InitPlanningContext ctx = new InitPlanningContext(scope, mock(AgentInstance.class), List.of(agent)); + planner.init(ctx); + + AgentMetadata metadata = planner.getAgentMetadata(0); + + assertThat(metadata.agentName()).isEqualTo("annotated"); + assertThat(metadata.systemMessage()).isEqualTo("You are a helpful assistant"); + assertThat(metadata.userMessage()).isEqualTo("Please help with: {{it}}"); + } + + @Test + void getAgentMetadataShouldReturnNullMessagesWhenNotAnnotated() { + AgentInstance agent = mock(AgentInstance.class); + when(agent.name()).thenReturn("no-messages"); + when(agent.type()).thenReturn((Class) AgentWithoutMessages.class); + + InitPlanningContext ctx = new InitPlanningContext(scope, mock(AgentInstance.class), List.of(agent)); + planner.init(ctx); + + AgentMetadata metadata = planner.getAgentMetadata(0); + + assertThat(metadata.agentName()).isEqualTo("no-messages"); + assertThat(metadata.systemMessage()).isNull(); + assertThat(metadata.userMessage()).isNull(); + } + + @Test + void getAgentMetadataShouldExtractSystemMessageOnly() { + AgentInstance agent = mock(AgentInstance.class); + when(agent.name()).thenReturn("system-only"); + when(agent.type()).thenReturn((Class) AgentWithSystemOnly.class); + + InitPlanningContext ctx = new InitPlanningContext(scope, mock(AgentInstance.class), List.of(agent)); + planner.init(ctx); + + AgentMetadata metadata = planner.getAgentMetadata(0); + + assertThat(metadata.agentName()).isEqualTo("system-only"); + assertThat(metadata.systemMessage()).isEqualTo("System prompt here"); + assertThat(metadata.userMessage()).isNull(); + } + + @Test + void getAgentMetadataShouldHandleNullType() { + AgentInstance agent = mock(AgentInstance.class); + when(agent.name()).thenReturn("null-type"); + when(agent.type()).thenReturn(null); + + InitPlanningContext ctx = new InitPlanningContext(scope, mock(AgentInstance.class), List.of(agent)); + planner.init(ctx); + + AgentMetadata metadata = planner.getAgentMetadata(0); + + assertThat(metadata.agentName()).isEqualTo("null-type"); + assertThat(metadata.systemMessage()).isNull(); + assertThat(metadata.userMessage()).isNull(); + } +} diff --git a/quarkus/runtime/src/test/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/ActivitiesTest.java b/quarkus/runtime/src/test/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/ActivitiesTest.java new file mode 100644 index 000000000..dc2b367e5 --- /dev/null +++ b/quarkus/runtime/src/test/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/ActivitiesTest.java @@ -0,0 +1,174 @@ +package io.quarkiverse.dapr.langchain4j.workflow.orchestration; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import java.util.List; +import java.util.Map; +import java.util.function.Predicate; + +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import dev.langchain4j.agentic.planner.AgentInstance; +import dev.langchain4j.agentic.planner.AgenticSystemTopology; +import dev.langchain4j.agentic.planner.InitPlanningContext; +import dev.langchain4j.agentic.scope.AgenticScope; +import io.dapr.workflows.WorkflowActivityContext; +import io.dapr.workflows.client.DaprWorkflowClient; +import io.quarkiverse.dapr.langchain4j.workflow.DaprPlannerRegistry; +import io.quarkiverse.dapr.langchain4j.workflow.DaprWorkflowPlanner; +import io.quarkiverse.dapr.langchain4j.workflow.orchestration.activities.AgentExecutionActivity; +import io.quarkiverse.dapr.langchain4j.workflow.orchestration.activities.ConditionCheckActivity; +import io.quarkiverse.dapr.langchain4j.workflow.orchestration.activities.ExitConditionCheckActivity; + +class ActivitiesTest { + + private DaprWorkflowPlanner planner; + private AgentInstance agent1; + private AgentInstance agent2; + + @BeforeEach + void setUp() { + DaprWorkflowClient client = mock(DaprWorkflowClient.class); + planner = new DaprWorkflowPlanner( + SequentialOrchestrationWorkflow.class, "test", + AgenticSystemTopology.SEQUENCE, client); + + agent1 = mock(AgentInstance.class); + when(agent1.name()).thenReturn("agent1"); + agent2 = mock(AgentInstance.class); + when(agent2.name()).thenReturn("agent2"); + AgenticScope scope = mock(AgenticScope.class); + + InitPlanningContext initCtx = new InitPlanningContext(scope, mock(AgentInstance.class), List.of(agent1, agent2)); + planner.init(initCtx); + } + + @AfterEach + void tearDown() { + DaprPlannerRegistry.unregister(planner.getPlannerId()); + } + + @Test + void agentExecutionActivityShouldSubmitAndReturnImmediately() { + AgentExecutionActivity activity = new AgentExecutionActivity(); + + WorkflowActivityContext ctx = mock(WorkflowActivityContext.class); + when(ctx.getInput(AgentExecInput.class)) + .thenReturn(new AgentExecInput(planner.getPlannerId(), 0, + planner.getPlannerId() + ":0")); + + // Activity should return immediately (non-blocking) + Object result = activity.run(ctx); + assertThat(result).isNull(); + } + + @Test + void agentExecutionActivityShouldThrowForUnknownPlanner() { + AgentExecutionActivity activity = new AgentExecutionActivity(); + + WorkflowActivityContext ctx = mock(WorkflowActivityContext.class); + when(ctx.getInput(AgentExecInput.class)) + .thenReturn(new AgentExecInput("nonexistent-planner", 0, "nonexistent-planner:0")); + + assertThatThrownBy(() -> activity.run(ctx)) + .isInstanceOf(IllegalStateException.class) + .hasMessageContaining("No planner found"); + } + + @Test + void exitConditionCheckActivityShouldReturnFalseWhenNoCondition() { + ExitConditionCheckActivity activity = new ExitConditionCheckActivity(); + + WorkflowActivityContext ctx = mock(WorkflowActivityContext.class); + when(ctx.getInput(ExitConditionCheckInput.class)) + .thenReturn(new ExitConditionCheckInput(planner.getPlannerId(), 0)); + + assertThat(activity.run(ctx)).isEqualTo(false); + } + + @Test + void exitConditionCheckActivityShouldEvaluateCondition() { + planner.setExitCondition((s, iter) -> iter >= 2); + + ExitConditionCheckActivity activity = new ExitConditionCheckActivity(); + + WorkflowActivityContext ctx = mock(WorkflowActivityContext.class); + + when(ctx.getInput(ExitConditionCheckInput.class)) + .thenReturn(new ExitConditionCheckInput(planner.getPlannerId(), 1)); + assertThat(activity.run(ctx)).isEqualTo(false); + + when(ctx.getInput(ExitConditionCheckInput.class)) + .thenReturn(new ExitConditionCheckInput(planner.getPlannerId(), 2)); + assertThat(activity.run(ctx)).isEqualTo(true); + } + + @Test + void exitConditionCheckActivityShouldThrowForUnknownPlanner() { + ExitConditionCheckActivity activity = new ExitConditionCheckActivity(); + + WorkflowActivityContext ctx = mock(WorkflowActivityContext.class); + when(ctx.getInput(ExitConditionCheckInput.class)) + .thenReturn(new ExitConditionCheckInput("nonexistent", 0)); + + assertThatThrownBy(() -> activity.run(ctx)) + .isInstanceOf(IllegalStateException.class); + } + + @Test + void conditionCheckActivityShouldReturnTrueByDefault() { + ConditionCheckActivity activity = new ConditionCheckActivity(); + + WorkflowActivityContext ctx = mock(WorkflowActivityContext.class); + when(ctx.getInput(ConditionCheckInput.class)) + .thenReturn(new ConditionCheckInput(planner.getPlannerId(), 0)); + + assertThat(activity.run(ctx)).isEqualTo(true); + } + + @Test + void conditionCheckActivityShouldEvaluateCondition() { + Predicate alwaysFalse = s -> false; + planner.setConditions(Map.of(0, alwaysFalse)); + + ConditionCheckActivity activity = new ConditionCheckActivity(); + + WorkflowActivityContext ctx = mock(WorkflowActivityContext.class); + when(ctx.getInput(ConditionCheckInput.class)) + .thenReturn(new ConditionCheckInput(planner.getPlannerId(), 0)); + + assertThat(activity.run(ctx)).isEqualTo(false); + } + + @Test + void conditionCheckActivityShouldReturnTrueForAgentWithoutCondition() { + Predicate alwaysFalse = s -> false; + planner.setConditions(Map.of(0, alwaysFalse)); + + ConditionCheckActivity activity = new ConditionCheckActivity(); + + // Agent index 1 has no condition mapped + WorkflowActivityContext ctx = mock(WorkflowActivityContext.class); + when(ctx.getInput(ConditionCheckInput.class)) + .thenReturn(new ConditionCheckInput(planner.getPlannerId(), 1)); + + assertThat(activity.run(ctx)).isEqualTo(true); + } + + @Test + void conditionCheckActivityShouldThrowForUnknownPlanner() { + ConditionCheckActivity activity = new ConditionCheckActivity(); + + WorkflowActivityContext ctx = mock(WorkflowActivityContext.class); + when(ctx.getInput(ConditionCheckInput.class)) + .thenReturn(new ConditionCheckInput("nonexistent", 0)); + + assertThatThrownBy(() -> activity.run(ctx)) + .isInstanceOf(IllegalStateException.class); + } +} \ No newline at end of file diff --git a/quarkus/runtime/src/test/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/InputRecordsTest.java b/quarkus/runtime/src/test/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/InputRecordsTest.java new file mode 100644 index 000000000..042f00173 --- /dev/null +++ b/quarkus/runtime/src/test/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/InputRecordsTest.java @@ -0,0 +1,51 @@ +package io.quarkiverse.dapr.langchain4j.workflow.orchestration; + +import static org.assertj.core.api.Assertions.assertThat; + +import org.junit.jupiter.api.Test; + +class InputRecordsTest { + + @Test + void agentExecInputShouldStoreFields() { + AgentExecInput input = new AgentExecInput("planner-abc", 2, "planner-abc:2"); + + assertThat(input.plannerId()).isEqualTo("planner-abc"); + assertThat(input.agentIndex()).isEqualTo(2); + assertThat(input.agentRunId()).isEqualTo("planner-abc:2"); + } + + @Test + void agentExecInputShouldSupportEquality() { + AgentExecInput a = new AgentExecInput("id", 1, "id:1"); + AgentExecInput b = new AgentExecInput("id", 1, "id:1"); + + assertThat(a).isEqualTo(b); + assertThat(a.hashCode()).isEqualTo(b.hashCode()); + } + + @Test + void conditionCheckInputShouldStoreFields() { + ConditionCheckInput input = new ConditionCheckInput("planner-xyz", 5); + + assertThat(input.plannerId()).isEqualTo("planner-xyz"); + assertThat(input.agentIndex()).isEqualTo(5); + } + + @Test + void exitConditionCheckInputShouldStoreFields() { + ExitConditionCheckInput input = new ExitConditionCheckInput("planner-loop", 7); + + assertThat(input.plannerId()).isEqualTo("planner-loop"); + assertThat(input.iteration()).isEqualTo(7); + } + + @Test + void differentRecordTypesShouldNotBeEqual() { + AgentExecInput agent = new AgentExecInput("id", 1, "id:1"); + ConditionCheckInput condition = new ConditionCheckInput("id", 1); + + // They're different record types, so they shouldn't be equal + assertThat(agent).isNotEqualTo(condition); + } +} diff --git a/quarkus/runtime/src/test/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/OrchestrationInputTest.java b/quarkus/runtime/src/test/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/OrchestrationInputTest.java new file mode 100644 index 000000000..7a0dfb879 --- /dev/null +++ b/quarkus/runtime/src/test/java/io/quarkiverse/dapr/langchain4j/workflow/orchestration/OrchestrationInputTest.java @@ -0,0 +1,35 @@ +package io.quarkiverse.dapr.langchain4j.workflow.orchestration; + +import static org.assertj.core.api.Assertions.assertThat; + +import org.junit.jupiter.api.Test; + +class OrchestrationInputTest { + + @Test + void shouldStoreAllFields() { + OrchestrationInput input = new OrchestrationInput("planner-1", 3, 10, true); + + assertThat(input.plannerId()).isEqualTo("planner-1"); + assertThat(input.agentCount()).isEqualTo(3); + assertThat(input.maxIterations()).isEqualTo(10); + assertThat(input.testExitAtLoopEnd()).isTrue(); + } + + @Test + void shouldSupportEquality() { + OrchestrationInput a = new OrchestrationInput("id", 2, 5, false); + OrchestrationInput b = new OrchestrationInput("id", 2, 5, false); + + assertThat(a).isEqualTo(b); + assertThat(a.hashCode()).isEqualTo(b.hashCode()); + } + + @Test + void shouldDetectInequality() { + OrchestrationInput a = new OrchestrationInput("id1", 2, 5, false); + OrchestrationInput b = new OrchestrationInput("id2", 2, 5, false); + + assertThat(a).isNotEqualTo(b); + } +} diff --git a/spotbugs-exclude.xml b/spotbugs-exclude.xml index 98645d005..d8237ca92 100644 --- a/spotbugs-exclude.xml +++ b/spotbugs-exclude.xml @@ -63,4 +63,18 @@ + + + + + + + + + + + + + + \ No newline at end of file