Struct LlmRequest 

pub struct LlmRequest {
    pub model: String,
    pub messages: Messages,
    pub system: Option<String>,
    pub max_tokens: Option<u32>,
    pub tools: Vec<ToolSpec>,
    pub effort: Option<String>,
    pub schema: Option<Value>,
}

A model call.

Fields

model: String

Which model to ask, in the provider’s naming.

messages: Messages

The conversation so far, oldest turn first.

system: Option<String>

System prompt, kept apart from messages because providers disagree about where it goes — a system turn, a top-level field, or folded into the first user turn. The client places it at its edge.

max_tokens: Option<u32>

Cap on generated tokens. A reply that hits it stops with StopReason::MaxTokens, which steps treat as an error, not an answer.

tools: Vec<ToolSpec>

Tools the model may call, as JSON Schema definitions.

effort: Option<String>

Reasoning depth, in the provider’s terms (low … max).

schema: Option<Value>

JSON Schema the reply must satisfy.

A request, not a guarantee: endpoints that support constrained decoding enforce it, and the rest are asked in the prompt and may still answer with prose. Whoever consumes the reply validates it — see crate::schema::Schema for the graph-level contract, which is a different thing: this constrains one model call, that one constrains an edge.

Implementations

impl LlmRequest

pub fn new(model: impl Into<String>, messages: Messages) -> Self

A request with only the essentials: a model and a conversation.

Everything else is opt-in through the with_* builders — and because unset options are skipped when the request is serialized, they are also absent from the journal key (Effect::cache_key). Growing this struct therefore never moves the keys of requests that predate the new knob.

pub fn with_system(self, system: impl Into<String>) -> Self

Set the system prompt.

Stated here once, placed by the provider client wherever this endpoint wants it — as its own turn, or prepended to the first user turn when the endpoint refuses a system role.

pub fn with_max_tokens(self, n: u32) -> Self

Cap the reply at n generated tokens.

A budget, not a target: a reply that runs into it is a cut-off thought, and LlmResponse::reject_non_answers turns it into an error rather than letting the fragment flow downstream as an answer.

pub fn with_tools(self, tools: Vec<ToolSpec>) -> Self

Offer the model these tools, replacing any previous set.

Offering is all this does. When the model wants one, the reply stops with StopReason::ToolUse and it is the step’s job to perform the calls — typically as Effect::Tool — and ask the model to continue with the results appended to the conversation.

pub fn with_effort(self, effort: impl Into<String>) -> Self

Ask for this much reasoning, in the provider’s vocabulary (low … max).

Passed through verbatim (reasoning_effort on OpenAI-shaped endpoints); endpoints without the concept ignore the unknown field. Like every other knob it is part of the journal key — the same question at a different effort is a different request, so a replay never serves the cheaper answer.

pub fn with_schema(self, schema: Value) -> Self

Ask for a reply shaped like schema.

pub fn into_effect(self) -> Effect

Wrap as the effect a step awaits.

Trait Implementations

impl Clone for LlmRequest

fn clone(&self) -> LlmRequest

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LlmRequest

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LlmRequest

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for LlmRequest

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.