PromptEnhancer builds a system prompt from prompting techniques such as chain of thought or self-verification. It only writes text. You send the prompt to the model yourself, and EnhancedResponse reads the reply.

Package: com.tnsai.prompt.strategy

Strategies

Each PromptStrategy adds an instruction to the system prompt. A multi-pass strategy asks the model to work in several passes inside one reply; the framework makes one call, not several.

Strategy	Adds instructions asking the model to	Multi-pass	Post-processing
`CHAIN_OF_THOUGHT`	Reason step by step before the final answer	No	No
`CHAIN_OF_VERIFICATION`	Answer, write verification questions, answer them, then revise	Yes	Yes
`CONFIDENCE_WEIGHTED`	Give a confidence level from 0 to 100%, its assumptions, and alternatives below 70%	No	No
`STRUCTURED_THINKING`	Work through UNDERSTAND, ANALYZE, STRATEGIZE and EXECUTE	No	No
`MULTI_PERSPECTIVE`	Weigh technical, business, user-experience and risk views, then recommend	No	No
`CONSTRAINT_FIRST`	Separate hard constraints from soft preferences before answering	No	No
`ITERATIVE_REFINEMENT`	Draft, critique, refine and review	Yes	Yes
`CONTEXT_BOUNDARIES`	Separate context, focus, task and constraints, and say when information is missing	No	No
`FEW_SHOT_EXAMPLES`	Follow the good and bad examples	No	No
`META_PROMPTING`	Design the best prompt for the task, then answer it	Yes	No
`SIX_PART_ANATOMY`	Answer in six parts: role, objective, request, process, output, stop	No	No
`ATOM_OF_THOUGHT`	Split the problem into independent sub-problems, solve each, then combine	Yes	No

Each value has getSystemInstruction(), getDescription(), isMultiPass() and requiresPostProcessing(). The last two only describe the strategy; nothing in the framework acts on them.

Build and send a prompt

PromptEnhancer.builder() collects strategies, a role, an objective, constraints, examples and an output format. enhance(userMessage) returns an EnhancedPrompt. For one strategy and nothing else, use PromptEnhancer.withStrategy(strategy).

package com.example.tnsai.docs;

import com.tnsai.llm.LLMClient;
import com.tnsai.prompt.strategy.EnhancedPrompt;
import com.tnsai.prompt.strategy.EnhancedResponse;
import com.tnsai.prompt.strategy.PromptEnhancer;
import com.tnsai.prompt.strategy.PromptStrategy;

public final class PromptStrategiesBuilderExample {
    private PromptStrategiesBuilderExample() {}

    static PromptEnhancer tutor() {
        return PromptEnhancer.builder()
            .role("Mathematics tutor")
            .objective("Solve algebra problems accurately")
            .strategy(PromptStrategy.CHAIN_OF_THOUGHT)
            .strategy(PromptStrategy.CONFIDENCE_WEIGHTED)
            .confidenceThreshold(0.7f)
            .constraint("Show all work")
            .positiveExample("2x = 10", "x = 5", "Divides both sides by 2")
            .negativeExample("2x = 10", "x = 10", "Forgets to divide")
            .outputFormat(PromptEnhancer.OutputFormat.STRUCTURED)
            .build();
    }

    // Build the prompt, send it yourself, then read the confidence line.
    static String solve(LLMClient llm, String problem) {
        EnhancedPrompt prompt = tutor().enhance(problem);
        String reply = llm.chat(prompt.getUserMessage(), prompt.getSystemPrompt()).getContent();

        EnhancedResponse parsed = EnhancedResponse.parse(reply);
        // getConfidence() is a percentage from 0 to 100.
        if (parsed.getConfidence().map(c -> c < 70f).orElse(false)) {
            return parsed.getMainContent() + "\nAlternatives: " + parsed.getAlternatives();
        }
        return parsed.getMainContent();
    }

    // For a model without a separate system prompt.
    static String combined(String problem) {
        return tutor().enhance(problem).getCombinedPrompt();
    }
}

Builder methods

All methods return the builder and can be called in any order.

Method	Adds to the system prompt
`strategy(PromptStrategy)`	The strategy's instruction. Call it once per strategy.
`role(String)`	The role line
`objective(String)`	The objective line
`constraint(String)`, `constraints(List<String>)`	A HARD CONSTRAINTS list
`softPreference(String)`, `softPreferences(List<String>)`	A SOFT PREFERENCES list
`processStep(String)`, `process(List<String>)`	A numbered PROCESS list
`positiveExample(input, output)`, `positiveExample(input, output, explanation)`	A good example
`negativeExample(input, badOutput, whyBad)`	A bad example
`outputFormat(PromptEnhancer.OutputFormat)`	The format instruction
`stopCondition(String)`	A STOP CONDITION line
`verificationQuestions(int)`	"Generate exactly N verification questions", with `CHAIN_OF_VERIFICATION` only
`refinementPasses(int)`	"Perform exactly N refinement passes", with `ITERATIVE_REFINEMENT` only
`confidenceThreshold(float)`	A threshold line as a percentage, with `CONFIDENCE_WEIGHTED` only. Pass a fraction: `0.7f` prints 70%.

Examples are PromptEnhancer.Example(input, output, explanation) records; the two-argument constructor leaves the explanation null.

`PromptEnhancer.OutputFormat`

This enum is nested in PromptEnhancer. It is not the OutputFormat used for parsing structured output.

Value	Instruction
`TEXT`	Provide your response as plain text.
`JSON`	Provide your response as valid JSON.
`MARKDOWN`	Format your response using Markdown.
`MARKDOWN_TABLE`	Format your response as a Markdown table.
`BULLET_POINTS`	Use bullet points for your response.
`NUMBERED_LIST`	Use a numbered list for your response.
`STRUCTURED`	Use clear sections with headers for your response.
`CODE`	Provide code with comments explaining each section.
`COMPARISON_TABLE`	Create a comparison table with pros/cons.

`EnhancedPrompt`

Method	Returns
`getSystemPrompt()`	The assembled system prompt
`getSystemPromptOptional()`	The same, as an `Optional<String>`
`getUserMessage()`	The message passed to `enhance`
`getCombinedPrompt()`	System prompt, a `---` separator, then the user message, for a model without a separate system prompt
`getStrategies()`	The strategies applied
`getOutputFormat()`	`Optional<PromptEnhancer.OutputFormat>`
`requiresMultiPass()`, `requiresPostProcessing()`	Whether any strategy is marked so
`expectsConfidenceScore()`, `expectsStructuredThinking()`, `expectsVerification()`	Whether `CONFIDENCE_WEIGHTED`, `STRUCTURED_THINKING` or `CHAIN_OF_VERIFICATION` is applied
`getEstimatedOverhead()`	The added characters divided by four, a rough token count

`EnhancedResponse`

EnhancedResponse.parse(reply) reads the sections the strategies asked for.

Method	Returns
`getMainContent()`	The reply with the confidence, assumptions and alternatives lines removed
`getConfidence()`	`Optional<Float>`, a percentage from 0 to 100
`isConfident(float)`	Whether the confidence is at least the threshold. The threshold is a percentage too: pass `70f`, not `0.7f`.
`getAssumptions()`, `getAlternatives()`, `getVerificationQuestions()`	The listed items
`getThinkingPhases()`, `getPhase(name)`	The `STRUCTURED_THINKING` phases
`hasStructuredThinking()`, `hasVerification()`, `hasAlternatives()`	Whether the sections are present
`getRawContent()`	The reply as received

`AgentBuilder` settings

AgentBuilder.promptStrategy, promptStrategies and promptEnhancer store their values, but nothing applies them. Not implemented: an agent's chat does not change. Call enhance yourself, as above.

Structured output: typed replies.
LLM actions: actions that call the model.

Prompt strategies