Reasoning

ThinkingResult result = ThinkingResult.builder()
    .thinkingProcess("Step 1: Analyze the input... Step 2: Consider edge cases...")
    .finalAnswer("The optimal solution is X because...")
    .thinkingTokens(1200)
    .outputTokens(350)
    .thinkingBlocks(List.of("analysis block", "verification block"))
    .build();

System.out.println(result.hasThinking());      // true
System.out.println(result.getTotalTokens());    // 1550
System.out.println(result.getFinalAnswer());

TreeOfThoughtsExecutor tot = TreeOfThoughtsExecutor.builder()
    .llm(client)
    .evaluator(BranchEvaluator.llm(evalClient))
    .pruning(PruningStrategy.BEAM_SEARCH)
    .beamWidth(3)
    .maxDepth(5)
    .branchingFactor(3)
    .pruneThreshold(0.3)
    .timeout(Duration.ofMinutes(10))
    .build();

ToTResult result = tot.explore("Design a REST API for a todo app");
System.out.println(result.getBestPath());
System.out.println(result.getBestScore());

ToTResult result = tot.explore("Optimize this algorithm");

result.getBestPath();           // Combined thought chain of best leaf
result.getBestScore();          // Average score along best path
result.hasSolution();           // true if bestScore > 0.5
result.getBestLeaf();           // Optional<ThoughtNode>
result.getTopPaths(3);          // Top-3 leaf nodes by score

result.getTotalNodes();         // Total nodes explored
result.getPrunedNodes();        // Nodes pruned during exploration
result.getMaxDepthReached();    // Deepest level reached
result.getDuration();           // Total exploration time

ThoughtNode root = ThoughtNode.root("Design a caching strategy");
ThoughtNode child = root.addChild("n1", "Use LRU cache with TTL");
child.setScore(0.85);

child.getThoughtChain();     // "Design a caching strategy -> Use LRU cache with TTL"
child.getCumulativeScore();  // Sum of scores along path
child.getAverageScore();     // Average score along path
child.getDepth();            // 1
child.isLeaf();              // true (no children yet)
child.isRoot();              // false
child.isEvaluated();         // true (score was set)
child.isPruned();            // false
child.getPath();             // [root, child]

// LLM-based: asks an LLM to rate the reasoning step 0-100
BranchEvaluator llmEval = BranchEvaluator.llm(evalClient);

// Heuristic: scores based on thought length and reasoning keywords
BranchEvaluator heuristic = BranchEvaluator.heuristic();

// Combined: averages multiple evaluators
BranchEvaluator combined = BranchEvaluator.combined(llmEval, heuristic);

// Custom evaluator
BranchEvaluator custom = (node, goal) -> {
    return node.getThought().contains("therefore") ? 0.8 : 0.4;
};

GraphOfThoughtsExecutor got = GraphOfThoughtsExecutor.builder()
    .llm(client)
    .evaluator(BranchEvaluator.llm(client))
    .operations(List.of(
        GoTOperation.GENERATE,
        GoTOperation.AGGREGATE,
        GoTOperation.REFINE))
    .maxNodes(20)
    .branchingFactor(3)
    .timeout(Duration.ofMinutes(10))
    .build();

GoTResult result = got.explore("Design a database schema for e-commerce");
System.out.println(result.getBestThought());
System.out.println(result.aggregatedInsight());
System.out.println(result.mergeCount());  // How many merge operations occurred

GoTNode root = GoTNode.root("Design a notification system");
GoTNode emailApproach = root.addChild("n1", "Use email queues", GoTOperation.GENERATE);
GoTNode pushApproach = root.addChild("n2", "Use push notifications", GoTOperation.GENERATE);

// Merge two approaches into one
GoTNode merged = GoTNode.merge("m1",
    "Hybrid: email for async, push for real-time",
    List.of(emailApproach, pushApproach));

merged.isMergeNode();       // true
merged.getParents().size(); // 2

GoTResult result = got.explore("...");
result.getBestThought();      // Content of the highest-scored node
result.getBestScore();        // Score of best node
result.totalNodes();          // Total nodes in graph
result.mergeCount();          // Number of AGGREGATE operations
result.hasSolution();         // true if bestScore > 0.5
result.aggregatedInsight();   // Synthesized insight from best nodes
result.duration();            // Exploration time

CausalReasoner reasoner = CausalReasoner.builder()
    .llm(client)
    .causalModel("Sales depend on marketing spend, season, and competitor pricing")
    .build();

Map<String, Object> context = Map.of(
    "q3_sales", 150000,
    "marketing_budget", 50000,
    "season", "summer"
);

// Why did something happen?
CausalResult why = reasoner.why("Why did sales drop in Q3?", context);
System.out.println(why.answer());
System.out.println(why.reasoning());
System.out.println(why.confidence()); // 0.0-1.0

// What-if counterfactual
CausalResult whatIf = reasoner.whatIf("What if we doubled marketing?", context);

// Intervention prediction
CausalResult intervene = reasoner.intervene("Cut prices by 15%", context);

SelfConsistencyExecutor executor = SelfConsistencyExecutor.builder()
    .llm(client)
    .numPaths(5)
    .aggregation(Aggregation.MAJORITY_VOTE)
    .baseTemperature(0.7)
    .temperatureVariance(0.1)
    .parallel(true)
    .maxConcurrency(5)
    .timeout(Duration.ofMinutes(5))
    .systemPrompt("You are a math tutor.")
    .build();

ConsistencyResult result = executor.reason("What is 17 * 23?");
System.out.println(result.getConsensusAnswer()); // "391"
System.out.println(result.getConfidence());       // 0.8 (4/5 paths agreed)
System.out.println(result.isUnanimous());          // false
System.out.println(result.getAnswerCounts());      // {"391"=4, "392"=1}

ConsistencyResult result = executor.reason("...");
result.getConsensusAnswer();  // The winning answer
result.getConfidence();       // Ratio of paths that agreed
result.getAllPaths();          // All ReasoningPath objects
result.getAnswerCounts();     // Map<String, Integer> of answer frequencies
result.getTotalPaths();       // Number of paths generated
result.isUnanimous();         // true if confidence >= 1.0
result.isConfident(0.8);      // true if confidence >= threshold