Struct Chat 

pub struct Chat {
    pub provider: OpenAIConfig,
    pub model: String,
    pub strict_tools: bool,
    pub tool_result_array_content: bool,
}

The chat-completions wire: a provider configuration, a model, and the per-turn options the endpoint takes.

Fields

provider: OpenAIConfig

Which provider, and how to reach it.

model: String

The model this wire addresses.

strict_tools: bool

Whether tool schemas are sanitized for OpenAI’s strict mode: additionalProperties: false on every object, every property required, and strict: true on each function definition.

tool_result_array_content: bool

Whether tool-result messages serialize their content as arrays.

Implementations

impl Chat

pub fn new(provider: OpenAIConfig, model: impl Into<String>) -> Self

The wire for model on provider, with every option off.

pub fn with_strict_tools(self) -> Self

Sanitize tool schemas for OpenAI’s strict mode, so the provider can guarantee a tool call matches its schema exactly.

pub fn with_tool_result_array_content(self) -> Self

Serialize tool-result content as arrays.

Trait Implementations

impl Clone for Chat

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Chat

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Chat

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Chat> for OpenAiWire

fn from(wire: Chat) -> Self

Converts to this type from the input type.

impl PartialEq for Chat

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl ReplayTarget for Chat

fn map_options( &self, request: &CompletionRequest, fields: OptionFields<'_>, ) -> OptionMap

Section 6.2 of the typed-options design, by dialect.

fn accepts(&self, model: &str) -> Accepts

Chat reads no images in assistant messages, images in tool results only on a dialect that says so, and tools where the dialect takes them. Which models read user images follows each provider’s documented model rules (reads_images).

fn encodes(&self, _model: &str, media: Media<'_>) -> bool

What the Chat encoder carries, by dialect: an image as a URL or typed data; audio as data; video as a URL or typed data, except to OpenAI, Azure and Mistral; a PDF as data, or as a URL OpenRouter or Mistral fetches; a file id where the dialect takes one; and a string document as text. DeepSeek and Mira take text only; Perplexity and Cohere take no media but images, and Ollama only images as data.

fn normalize_tool_call_id( &self, id: &str, _model: &str, _: Option<&Origin>, ) -> String

pi’s rule for this wire. A call|item id joins its sanitized halves with _, ending a result over 40 characters in a hash of the whole id; OpenAI’s own ids are cut to 40; any other id is kept. Mistral takes any such id (checked live on eight models), where pi derives nine alphanumerics.

fn identity(&self, item: &Value) -> Map<String, Value>

What an edited block keeps of its item: a custom call’s kind and Mistral’s thinking part (type), or the field reasoning arrived in, as pi keeps thinkingSignature. Signed data such as reasoning_details never survives an edit.

fn result_parts(&self, _model: &str) -> bool

In array mode a result’s parts go as an array.

fn sends_alone(&self, block: &AssistantContent) -> bool

A Chat message needs content or calls, as pi’s rebuild does: text only when it is not empty or its item carries audio, reasoning only as a content part (Mistral’s thinking), an opaque item only as a typed part, and never an image.

fn api(&self) -> Api

The wire format.

fn provider(&self) -> &str

The provider descriptor name.

fn model(&self) -> &str

The model id the wire addresses.

fn call_id_slot(&self) -> Option<&'static str>

Where a tool call’s id sits in this wire’s call item, as a JSON pointer, when it has one. Replay writes the call’s wire id there, so a replayed item and its result always agree, and a call the provider sent without an id keeps its item only on a wire with a slot.

fn later_system(&self, _model: &str) -> LaterSystem

Where model takes system messages that come after the conversation begins (LaterSystem). By default where the history has them.

fn continues_stored(&self, request: &CompletionRequest) -> bool

Whether request continues a conversation the provider stores, such as one naming a previous interaction. Results before the history’s first turn then answer calls the provider holds, so adapt keeps them.

fn declares_tools(&self, request: &CompletionRequest) -> bool

Whether request declares tools to the provider, in tools, in the tools of its additional_params, or through tools the wire adds. A request that declares none gets its history’s calls and results as text. ToolChoice::None still declares them: the wire sends its own none choice beside the tool history.

fn states_finish_reason(&self) -> bool

Whether every reply on this wire states why it stopped. A reply that then names no reason failed (pi’s supportsFinishReason); a wire with no finish vocabulary, such as a local runtime, says false.

fn binds_context(&self, model: &str) -> bool

Whether model binds its provider items to the request’s tools and system prompt, so a turn made under another context replays as if from another model.

fn drops_unbound_items(&self, request: &CompletionRequest) -> bool

Whether request asks the provider to drop an item bound to another context itself (Anthropic’s drop_block), so a turn made under another context replays verbatim rather than as another model’s.

fn route(&self, request: &CompletionRequest) -> Option<&dyn ReplayTarget>

The target request is sent to, for a wire that picks its API per request. Preparing the request and folding its reply both read the target this names, so a turn records the API it was made on. None, the default, is this target.

fn takes_documents(&self) -> bool

Whether the encoder sends a request’s documents itself. Otherwise they join the history as text before it is adapted.

fn needs_next(&self, item: &Value) -> bool

Whether this provider item requires the item after it in its turn (Responses reasoning): when that one is not replayed, neither is this.

fn hosted_pair(&self, item: &Value) -> Option<(Pairing, String)>

The hosted-tool pair this opaque item belongs to: whether it is the use or the result, and the id they share. A use and its result replay only together, in one turn or across the model’s turns. A use still running when the last turn ended (a paused turn, or one whose client call the hosted tool made) replays alone.

fn starts_with_user(&self) -> bool

Whether the wire rejects a conversation whose first message after the system prompt is not a user message. adapt then drops the assistant turns before the first user message, with their results.

fn alternates_roles(&self) -> bool

Whether the wire requires user and assistant messages to alternate. adapt then joins two messages of one role that only system messages separate, which move after them.

fn hosted_needs_tools(&self) -> bool

Whether a hosted tool’s use and result need the request to declare tools. A request that declares none then sends neither.

impl Serialize for Chat

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Chat

impl Wire for Chat

fn describe(&self) -> Descriptor<'_>

Format deferral permits tool composition; dialects without schema support require the agent’s tool-mode enforcement instead.

type Op = Completion

The operation this wire performs.

type Payload = Encoded

What Self::encode produces for the transport to send.

type Frame = WireFrame

One unit of a reply, as the transport delivers it.

type Decoder<'id> = ChatDecoder

The decoder for one of its replies, branded with that reply.

type Reassembler = ChatCompletion

What rebuilds a reply’s provider document from its frames when the transport reports no whole document, as for a stream. The driver feeds it every frame and records what it finishes with as raw. A wire whose operation’s decoders record raw themselves names document::Unreassembled; a completion wire cannot, because it does not Serve completions.

fn encode( &self, request: CompletionRequest, mode: Mode, ) -> Result<Encoded, EncodeError>

The request to send. Pure: it may read self, request and mode, and nothing else. A request that cannot be built is an EncodeError, which always reports as a request failure.

fn decoder<'id>(&self) -> Self::Decoder<'id>

A fresh decoder for one reply.

fn reassembler(&self) -> Self::Reassembler

A fresh reassembler for one reply. A wire that picks its API per reply builds the matching one.