Struct CompletionRequest 

pub struct CompletionRequest {
    pub model: Option<String>,
    pub preamble: Option<String>,
    pub chat_history: Vec<Message>,
    pub documents: Vec<Document>,
    pub tools: Vec<ToolDefinition>,
    pub temperature: Option<f64>,
    pub max_tokens: Option<u64>,
    pub tool_choice: Option<ToolChoice>,
    pub additional_params: Option<Value>,
    pub output_schema: Option<Schema>,
    pub record_telemetry_content: bool,
}

Struct representing a general completion request that can be sent to a completion model provider.

Fields

model: Option<String>

Optional model override for this request.

preamble: Option<String>

Legacy preamble field preserved for backwards compatibility.

New code should prefer a leading Message::System in chat_history as the canonical representation of system instructions.

chat_history: Vec<Message>

The chat history to be sent to the completion model provider. The very last message is the prompt.

This used to be a non-empty container, so “there is always at least one” was a type guarantee. It is a Vec now and the field is public, so the guarantee is a rule instead: it is checked by CompletionRequest::validate_message_content at the request boundary.

documents: Vec<Document>

The documents to be sent to the completion model provider

tools: Vec<ToolDefinition>

The tools to be sent to the completion model provider

temperature: Option<f64>

The temperature to be sent to the completion model provider

max_tokens: Option<u64>

The max tokens to be sent to the completion model provider

tool_choice: Option<ToolChoice>

Whether tools are required to be used by the model provider or not before providing a response.

additional_params: Option<Value>

Additional provider-specific parameters to be sent to the completion model provider

output_schema: Option<Schema>

Optional JSON Schema for structured output. When set, providers that support native structured outputs will constrain the model’s response to match this schema.

record_telemetry_content: bool

Whether to record sensitive request, response, and tool content on GenAI telemetry spans.

Defaults to false. Enabling this can expose prompts, retrieved context, tool results, model responses, and other sensitive or high-cardinality data through OpenTelemetry span attributes, which can increase observability backend storage and query costs. Only enable it when the caller has explicitly opted in to content telemetry.

Higher-level agent drivers use this flag for portable input, output, and tool-content telemetry. Direct provider calls only forward the policy; the exact content fields available there are provider- and surface-dependent, especially for streaming responses that are consumed after the provider returns.

This is local observability policy and is never serialized into provider request payloads.

Implementations

impl CompletionRequest

pub fn validate_message_content(&self) -> Result<(), CompletionError>

Reject a request with no messages, or a message that carries no content.

Removing the non-empty container removed two guarantees at once, and this is where both are restated:

• chat_history was non-empty by construction. As a Vec it is not, and the field is public, so CompletionRequest { chat_history: vec![], .. } is constructible and would reach a provider as messages: [] — a remote 400 in place of a local error that names the problem.
• Message content was likewise non-empty by construction, and every wire rejects an empty content block.

The rule also covers the block list inside a tool result. A user message carrying one UserContent::ToolResult is itself non-empty, but ToolResult::content was non-empty by construction under the removed container and is request-direction data just like the message content around it — so its check is relocated here rather than dropped. Only a tool result with zero blocks is rejected; a tool that legitimately returned an empty string produces one block and still sends.

This is the request direction only, and the asymmetry is deliberate. Empty assistant content is a real provider outcome on the response path — a tool-call-only turn, a content-filtered turn, a truncated stream — and the agent layer drops such a turn rather than sending it, so it never reaches here. The response direction is guarded per-wire instead, by crate::message::require_non_empty, because “this provider returned nothing where its protocol promises content” is a judgement only the provider’s own conversion can make.

System content is deliberately not checked. It is a String and always has been, so the removed container never constrained it; rejecting an empty one would be a new restriction rather than a relocated enforcement point, and would break a history carrying a conditionally built preamble that resolved to "".

Where this runs. CompletionRequestBuilder::send and CompletionRequestBuilder::stream call it, which covers both agent surfaces too — the blocking and streaming turn drivers both issue their request through the builder. Handing a request straight to a CompletionModel bypasses it; call this yourself there.

pub fn output_schema_name(&self) -> Option<String>

Extracts a name from the output schema’s "title" field, falling back to "response_schema". Useful for providers that require a name alongside the JSON Schema (e.g., OpenAI).

pub fn normalized_documents(&self) -> Option<Message>

Returns documents normalized into a message (if any). Most providers do not accept documents directly as input, so it needs to convert into a Message so that it can be incorporated into chat_history.

Trait Implementations

impl Clone for CompletionRequest

fn clone(&self) -> CompletionRequest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CompletionRequest

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CompletionRequest

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for CompletionRequest

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

where __S: Serializer,

Serialize this value into the given Serde serializer.