Struct P 

pub struct P;

The P namespace — static factory methods for prompt sections.

Implementations

impl P

pub fn role(role: &str) -> PromptSection

Define the agent’s role.

pub fn task(task: &str) -> PromptSection

Define the agent’s task.

pub fn constraint(c: &str) -> PromptSection

Add a constraint.

pub fn format(f: &str) -> PromptSection

Specify output format.

pub fn example(input: &str, output: &str) -> PromptSection

Add an input/output example.

pub fn text(t: &str) -> PromptSection

Add free-form text.

pub fn context(ctx: &str) -> PromptSection

Add background context.

pub fn persona(desc: &str) -> PromptSection

Define a personality/persona.

pub fn guidelines(items: &[&str]) -> PromptSection

Add multiple guidelines as a bulleted list.

pub fn section(name: &str, text: &str) -> PromptSection

Add a named section (flexible section kind).

pub fn template(tpl: &str) -> PromptSection

Template with {key} placeholders — rendered with state values at runtime.

pub fn reorder(order: &[&str]) -> PromptTransform

Reorder sections in a composite by name.

Sections whose names match the given order come first (in order); unmatched sections are appended at the end in their original order.

let prompt = (P::role("analyst") + P::task("analyze") + P::format("JSON"))
    .reorder_by_name(&["format", "role", "task"]);

pub fn only(names: &[&str]) -> PromptTransform

Keep only sections whose names match the given list.

let prompt = (P::role("analyst") + P::task("analyze") + P::format("JSON"))
    .only_by_name(&["role", "task"]);

pub fn without(names: &[&str]) -> PromptTransform

Remove sections whose names match the given list.

let prompt = (P::role("analyst") + P::task("analyze") + P::format("JSON"))
    .without_by_name(&["format"]);

pub fn compress() -> PromptSection

Mark prompt for compression. This is a placeholder/marker indicating the prompt content should be compressed before sending to the model.

pub fn adapt<F>(f: F) -> PromptSection

where F: Fn(&str) -> String + Send + Sync + 'static,

Create an adaptive prompt that adjusts based on a context function.

The function receives context (e.g., token budget, turn count) and returns the adapted prompt text.

let prompt = P::adapt(|ctx| {
    if ctx.contains("detailed") {
        "Provide a thorough analysis with citations.".to_string()
    } else {
        "Be concise.".to_string()
    }
});

pub fn scaffolded(steps: &[&str]) -> PromptSection

Create a step-by-step scaffolded prompt from ordered steps.

let prompt = P::scaffolded(&["Identify the problem", "Gather data", "Analyze", "Conclude"]);

pub fn versioned(version: &str, text: &str) -> PromptSection

Create a versioned prompt section with a version tag.

let prompt = P::versioned("v2.1", "Analyze the data using the new methodology");

pub fn with_state(keys: &[&str]) -> InstructionModifier

Create a state-append modifier that renders selected state keys into the instruction.

let modifiers = P::with_state(&["emotional_state", "willingness_to_pay"]);

pub fn when( predicate: impl Fn(&State) -> bool + Send + Sync + 'static, text: impl Into<String>, ) -> InstructionModifier

Create a conditional modifier that appends text when the predicate is true.

let risk_mod = P::when(risk_is_elevated, "IMPORTANT: Show extra empathy.");

pub fn context_fn( f: impl Fn(&State) -> String + Send + Sync + 'static, ) -> InstructionModifier

Create a custom-append modifier from a formatting function.

let ctx = P::context_fn(|s| format!("Customer: {}", s.get::<String>("name").unwrap_or_default()));