Agent Advisors API

import org.springaicommunity.agents.client.AgentClientRequest;
import org.springaicommunity.agents.client.AgentClientResponse;
import org.springaicommunity.agents.client.advisor.api.AgentCallAdvisor;
import org.springaicommunity.agents.client.advisor.api.AgentCallAdvisorChain;

public class SimpleLoggerAdvisor implements AgentCallAdvisor {

  @Override
  public AgentClientResponse adviseCall(AgentClientRequest request, AgentCallAdvisorChain chain) {
    // Log before execution
    System.out.println("Goal: " + request.goal().getContent());

    // Continue the chain
    AgentClientResponse response = chain.nextCall(request);

    // Log after execution
    System.out.println("Success: " + response.agentResponse().getResult());

    return response;
  }

  @Override
  public String getName() {
    return "SimpleLogger";
  }

  @Override
  public int getOrder() {
    return 0; // Execute early in the chain
  }
}

AgentClient client = AgentClient.builder(agentModel)
    .defaultAdvisor(new SimpleLoggerAdvisor())
    .build();

client.run("Create a Hello World Java class");
// Console output:
// Goal: Create a Hello World Java class
// Success: Created HelloWorld.java successfully

import java.nio.file.Path;
import java.nio.file.Files;
import java.util.stream.Collectors;

public class WorkspaceContextAdvisor implements AgentCallAdvisor {

  @Override
  public AgentClientResponse adviseCall(AgentClientRequest request, AgentCallAdvisorChain chain) {
    // Inject workspace info into context before execution
    Path workspace = request.workingDirectory();
    String workspaceInfo = analyzeWorkspace(workspace);
    request.context().put("workspace_info", workspaceInfo);
    request.context().put("workspace_analyzed_at", System.currentTimeMillis());

    // Continue the chain
    AgentClientResponse response = chain.nextCall(request);

    // Add execution metrics to response context
    int filesModified = countModifiedFiles(response);
    response.context().put("files_modified", filesModified);
    response.context().put("workspace_path", workspace.toString());

    return response;
  }

  private String analyzeWorkspace(Path workspace) {
    try {
      long fileCount = Files.walk(workspace)
        .filter(Files::isRegularFile)
        .count();
      return String.format("Workspace contains %d files", fileCount);
    } catch (Exception e) {
      return "Unable to analyze workspace";
    }
  }

  private int countModifiedFiles(AgentClientResponse response) {
    // Implementation would check file system changes
    return 0; // Placeholder
  }

  @Override
  public String getName() {
    return "WorkspaceContext";
  }

  @Override
  public int getOrder() {
    return 100; // Execute after high-priority advisors
  }
}

AgentClient client = AgentClient.builder(agentModel)
    .defaultAdvisor(new WorkspaceContextAdvisor())
    .build();

AgentClientResponse response = client
    .goal("Refactor UserService class")
    .workingDirectory(projectRoot)
    .run();

// Access context data
String workspaceInfo = (String) response.context().get("workspace_info");
int filesModified = (int) response.context().get("files_modified");
System.out.println(workspaceInfo + ", modified " + filesModified + " files");

import java.util.List;

public class GoalValidationAdvisor implements AgentCallAdvisor {

  private final List<String> bannedOperations = List.of(
    "rm -rf",
    "DROP DATABASE",
    "DELETE FROM",
    "format disk"
  );

  @Override
  public AgentClientResponse adviseCall(AgentClientRequest request, AgentCallAdvisorChain chain) {
    String goal = request.goal().getContent().toLowerCase();

    // Block dangerous operations
    for (String banned : bannedOperations) {
      if (goal.contains(banned.toLowerCase())) {
        // Create a failure response without calling the agent
        return new AgentClientResponse(
          createBlockedResponse("Goal blocked: contains dangerous operation '" + banned + "'")
        );
      }
    }

    // Validate goal is not empty
    if (goal.trim().isEmpty()) {
      return new AgentClientResponse(
        createBlockedResponse("Goal blocked: goal cannot be empty")
      );
    }

    // Goal is valid, continue the chain
    return chain.nextCall(request);
  }

  private AgentResponse createBlockedResponse(String reason) {
    // Create an agent response indicating blocked execution
    List<AgentGeneration> generations = List.of(
      new AgentGeneration(reason, new AgentGenerationMetadata("BLOCKED", Map.of()))
    );
    return new AgentResponse(generations);
  }

  @Override
  public String getName() {
    return "GoalValidation";
  }

  @Override
  public int getOrder() {
    return Ordered.HIGHEST_PRECEDENCE; // Execute first for security
  }
}

AgentClient client = AgentClient.builder(agentModel)
    .defaultAdvisor(new GoalValidationAdvisor())
    .build();

// This will be blocked
AgentClientResponse response = client.run("rm -rf /important/data");
System.out.println(response.agentResponse().getResult().getOutput());
// Output: Goal blocked: contains dangerous operation 'rm -rf'

import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Timer;

public class MetricsAdvisor implements AgentCallAdvisor {

  private final MeterRegistry meterRegistry;

  public MetricsAdvisor(MeterRegistry meterRegistry) {
    this.meterRegistry = meterRegistry;
  }

  @Override
  public AgentClientResponse adviseCall(AgentClientRequest request, AgentCallAdvisorChain chain) {
    Timer.Sample sample = Timer.start(meterRegistry);

    try {
      AgentClientResponse response = chain.nextCall(request);

      // Record successful execution
      sample.stop(Timer.builder("agent.execution")
        .tag("success", "true")
        .tag("goal_length", String.valueOf(request.goal().getContent().length()))
        .register(meterRegistry));

      // Record additional metrics
      meterRegistry.counter("agent.goals.completed").increment();

      return response;

    } catch (Exception e) {
      // Record failed execution
      sample.stop(Timer.builder("agent.execution")
        .tag("success", "false")
        .tag("error", e.getClass().getSimpleName())
        .register(meterRegistry));

      meterRegistry.counter("agent.goals.failed").increment();
      throw e;
    }
  }

  @Override
  public String getName() {
    return "Metrics";
  }

  @Override
  public int getOrder() {
    return Ordered.HIGHEST_PRECEDENCE + 500; // Early in chain for accurate metrics
  }
}