@SystemPrompt("You extract structured information from restaurant reviews.")
public class E02_StructuredOutput extends Agent {

    public record ReviewSummary(int rating, String sentiment,
                                java.util.List<String> highlights) {
    }

    @Generative("Extract a rating out of 5, an overall sentiment word, "
              + "and up to 3 highlight phrases from the review.")
    public ReviewSummary summarize(String review) {
        return generate(review);
    }

    public static void main(String[] args) {
        E02_StructuredOutput agent = new E02_StructuredOutput(
                AgentConfig.builder().llmClient(ExampleSetup.createLlmClient()).build());

        ReviewSummary summary = agent.summarize(
                "The ramen was incredible and the service was fast, but the "
              + "restaurant was quite loud and cramped.");

        System.out.println("rating: "     + summary.rating());
        System.out.println("sentiment: "  + summary.sentiment());
        System.out.println("highlights: " + summary.highlights());
    }
}

@SystemPrompt("You are a sprint-planning assistant.")
public class E07_ContextBlocks extends Agent {

    private int backlogSize = 5;

    public String formatBacklog() {
        return backlogSize + " item(s) remaining";
    }

    public void addBacklogItem() {
        backlogSize++;
    }

    @Generative("Given the sprint plan and current backlog in context, "
              + "suggest what to tackle next.")
    public String suggestNextStep() {
        return generate();
    }

    public static void main(String[] args) {
        E07_ContextBlocks agent = new E07_ContextBlocks(
                AgentConfig.builder().llmClient(ExampleSetup.createLlmClient()).build());

        agent.context.put("plan", "Sprint goal: ship the billing export by Friday.");
        agent.context.setDynamic("backlog", "self.formatBacklog()");

        System.out.println(agent.suggestNextStep());

        agent.addBacklogItem();
        System.out.println(agent.context.get("backlog"));   // "6 item(s) remaining"
    }
}

@SystemPrompt("You are a support agent with long-term memory of past interactions.")
public class E12_Memory extends Agent {

    @Doc("Remembers a fact about a customer for future reference.")
    public String rememberFact(String fact) {
        Memory memory = this.memory.remember(fact);
        return "stored as " + memory.getId();
    }

    @Doc("Recalls the most relevant remembered facts for a query.")
    public String recallFacts(String query) {
        StringBuilder sb = new StringBuilder();
        for (Memory memory : this.memory.recall(query, 3)) {
            sb.append("- ").append(memory.getContent()).append("\n");
        }
        return sb.length() == 0 ? "(nothing relevant remembered)" : sb.toString();
    }

    @Generative(value = "Using self.recallFacts if useful, answer the customer's "
                      + "question. Remember any new fact they share via self.rememberFact.",
            strategy = StrategyKind.TOOL_CALLING)
    public String converse(String customerMessage) {
        return generate(customerMessage);
    }

    public static void main(String[] args) {
        E12_Memory agent = new E12_Memory(AgentConfig.builder()
                .llmClient(ExampleSetup.createLlmClient())
                .embedder(ExampleSetup.createEmbedder())
                .build());

        System.out.println(agent.converse(
                "Hi, I'm on the Enterprise plan and prefer email over phone."));
        System.out.println(agent.converse("How do you prefer to reach me again?"));
    }
}

TraceViewerServer viewer = new TraceViewerServer();
Tracer.addExporter(viewer);
viewer.start(5001);

EvalSuite<String> suite = EvalSuite.<String>builder("ticket-triage-v1")
        .addCase(EvalCase.builder("billing-1", new EvalTask<String>() {
            @Override
            public String run() {
                return agent.classify("I was charged twice for my subscription.");
            }
        }).displayName("Duplicate charge")
          .expected("billing")
          .tier(Tier.STABLE)
          .metadata("difficulty", "easy").build())
        .addCase(EvalCase.builder("ambiguous-1", new EvalTask<String>() {
            @Override
            public String run() {
                return agent.classify("My invoice shows a technical-looking "
                                    + "error code instead of the amount due.");
            }
        }).displayName("Invoice shows an error code")
          .expected("billing")
          .tier(Tier.FRONTIER)
          .metadata("difficulty", "hard").build())
        .build();

List<EvalResult<String>> results =
        EvalRunner.run(suite, new ContainsScorer(), agent.getLlmClient().modelName());

for (EvalResult<String> result : results) {
    System.out.println((result.isPassed() ? "PASS" : "FAIL")
            + "  " + result.getCaseId()
            + "  expected=" + result.getExpected()
            + "  actual="   + result.getActual());
}