import ai.acolite.agentsdk.core.Agent;
import ai.acolite.agentsdk.core.RunResult;
import ai.acolite.agentsdk.core.Runner;
import ai.acolite.agentsdk.core.types.TextOutput;
import ai.acolite.agentsdk.core.types.UnknownContext;

public class HelloWorld {
    public static void main(String[] args) {
        // Create a simple agent
        Agent<UnknownContext, TextOutput> agent =
            Agent.<UnknownContext, TextOutput>builder()
                .name("Assistant")
                .instructions("You are a helpful assistant.")
                .build();

        // Run the agent
        RunResult<UnknownContext, ?> result =
            Runner.run(agent, "What is the capital of France?");

        // Print the response
        System.out.println(result.getFinalOutput());
    }
}

Agent<UnknownContext, TextOutput> agent =
    Agent.<UnknownContext, TextOutput>builder()
        .name("MathAssistant")
        .instructions("You are a math tutor. Use the calculator tool to perform calculations.")
        .tools(List.of(new CalculatorTool()))
        .build();

public class CalculatorTool
    implements FunctionTool<Object, CalculatorTool.Input, CalculatorTool.Output> {

  @Data
  @JsonClassDescription("Input parameters for arithmetic operations")
  public static class Input {
    @JsonPropertyDescription("The arithmetic operation: add, subtract, multiply, or divide")
    private String operation;
    @JsonPropertyDescription("The first number")
    private double a;
    @JsonPropertyDescription("The second number")
    private double b;
  }

  @Data
  @AllArgsConstructor
  public static class Output {
    private double result;
    private String operation;
    private String expression;
  }

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

  @Override
  public String getDescription() {
    return "Performs basic arithmetic operations.";
  }

  @Override
  public Object getParameters() {
    return Input.class;
  }

  @Override
  public CompletableFuture<Output> invoke(RunContext<Object> context, Input input) {
    return CompletableFuture.supplyAsync(() -> {
      double result = switch (input.getOperation()) {
        case "add" -> input.getA() + input.getB();
        case "subtract" -> input.getA() - input.getB();
        case "multiply" -> input.getA() * input.getB();
        case "divide" -> input.getA() / input.getB();
        default -> throw new IllegalArgumentException("Unknown operation");
      };
      return new Output(result, input.getOperation(),
          String.format("%.2f %s %.2f = %.2f", input.getA(),
              input.getOperation(), input.getB(), result));
    });
  }
}

import ai.acolite.agentsdk.core.HostedTool;

// Web search
Agent<UnknownContext, TextOutput> searchAgent =
    Agent.<UnknownContext, TextOutput>builder()
        .name("SearchAssistant")
        .instructions("You can search the web for current information.")
        .tools(List.of(HostedTool.webSearch()))
        .build();

// Image generation
Agent<UnknownContext, TextOutput> artistAgent =
    Agent.<UnknownContext, TextOutput>builder()
        .name("Artist")
        .instructions("You can generate images using DALL-E.")
        .tools(List.of(HostedTool.imageGeneration()))
        .build();

// Create specialist agents
Agent<UnknownContext, TextOutput> supportAgent =
    Agent.<UnknownContext, TextOutput>builder()
        .name("Technical Support")
        .instructions("You are a technical support specialist.")
        .handoffDescription("Handles technical support questions")
        .build();

Agent<UnknownContext, TextOutput> billingAgent =
    Agent.<UnknownContext, TextOutput>builder()
        .name("Billing Support")
        .instructions("You handle billing and payment questions.")
        .handoffDescription("Handles billing and payment questions")
        .build();

// Create triage agent with handoffs
Agent<UnknownContext, TextOutput> triageAgent =
    Agent.<UnknownContext, TextOutput>builder()
        .name("Triage")
        .instructions("You route customer requests to the right specialist.")
        .handoffs(List.of(supportAgent, billingAgent))
        .build();

// Run - automatically hands off to appropriate agent
RunResult<UnknownContext, ?> result =
    Runner.run(triageAgent, "My app keeps crashing, can you help?");

import ai.acolite.agentsdk.core.Session;
import ai.acolite.agentsdk.core.memory.MemorySession;
import ai.acolite.agentsdk.core.RunConfig;

// Create an in-memory session
Session session = new MemorySession("conversation-123");

// Create agent
Agent<UnknownContext, TextOutput> agent =
    Agent.<UnknownContext, TextOutput>builder()
        .name("Assistant")
        .instructions("You are a helpful assistant with a good memory.")
        .build();

// Use session across multiple turns
RunConfig config = RunConfig.builder().session(session).build();

// Turn 1
Runner.run(agent, "My name is Alice and I love hiking.", config);

// Turn 2
Runner.run(agent, "What's the capital of France?", config);

// Turn 3 - agent remembers your name!
RunResult<UnknownContext, ?> result =
    Runner.run(agent, "What's my name?", config);
// Response: "Your name is Alice!"

import ai.acolite.agentsdk.core.memory.SQLiteSession;

Session session = new SQLiteSession("conversations.db", "user-123");

import ai.acolite.agentsdk.core.tracing.TraceProvider;
import ai.acolite.agentsdk.core.tracing.ConsoleTraceProcessor;

// Enable console tracing (development)
TraceProvider.configure(new ConsoleTraceProcessor());

// All agent operations are automatically traced
Agent<UnknownContext, TextOutput> agent =
    Agent.<UnknownContext, TextOutput>builder()
        .name("TracedAgent")
        .instructions("You are a helpful assistant.")
        .build();

Runner.run(agent, "Hello!");
// Traces will be printed to console showing execution flow