Struct NativeChat 

pub struct NativeChat {
    pub provider: CohereConfig,
    pub model: String,
    pub strict_tools: bool,
}

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

Fields

provider: CohereConfig

Which provider, and how to reach it.

model: String

The model this wire addresses.

strict_tools: bool

Whether requests ask Cohere to hold tool calls to their schemas (strict_tools).

Implementations

impl NativeChat

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

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

pub fn with_strict_tools(self) -> Self

Ask Cohere to hold every tool call to its tool’s schema.

Trait Implementations

impl Clone for NativeChat

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 NativeChat

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NativeChat

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for NativeChat

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

Equality operator ==.

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

Inequality operator !=.

impl ReplayTarget for NativeChat

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

Section 6.5 of the typed-options design, for the native API.

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

Cohere’s vision models read user images; no model reads images in assistant turns or tool results.

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

The encoder carries a user image by URL or typed data, and a text document as its text. It carries no other media.

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

An edited block keeps its kind: a tool plan stays a plan.

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

Text and thinking with text are content parts, an opaque item with a type is a part, and a call is a call. A tool plan rides with its calls, and images are never sent.

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 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 normalize_tool_call_id( &self, id: &str, model: &str, source: Option<&Origin>, ) -> String

The id id takes when a call another model made is sent to model on this wire. source is the call’s origin, None for a hand-built turn. Results answering the call are rewritten to match, and an id another call already took is made distinct.

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 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 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 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.

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

Whether model reads a tool result as several parts. When it reads neither parts nor result images, adapt joins a result’s text parts into one.

impl Serialize for NativeChat

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 NativeChat

impl Wire for NativeChat

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 = ChatResponse

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 describe(&self) -> Descriptor<'_>

What the wire says about itself.

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.