Struct Client 

pub struct Client<Ext = Nothing, H = Client> { /* private fields */ }

Generic provider client shared by Rig provider integrations.

Ext stores provider-specific behavior such as URL construction, request customization, and capabilities. H is the HTTP backend and defaults to reqwest::Client.

Implementations

impl<Ext> Client<Ext, Client>

where Ext: Provider, Ext::Builder: ProviderBuilder<Extension<Client> = Ext> + Default,

new is pinned to H = reqwest::Client so the call site infers without an explicit H annotation. Callers who want a different backend should go through Client::builder and chain ClientBuilder::http_client before ClientBuilder::build.

pub fn new( api_key: impl Into<<Ext::Builder as ProviderBuilder>::ApiKey>, ) -> Result<Self>

Construct a provider client using the default reqwest::Client backend.

impl<Ext, H> Client<Ext, H>

pub fn base_url(&self) -> &str

Returns the configured provider base URL.

pub fn headers(&self) -> &HeaderMap

Returns default headers applied to outgoing provider requests.

pub fn ext(&self) -> &Ext

Returns the provider extension.

pub fn with_ext<NewExt>(self, new_ext: NewExt) -> Client<NewExt, H>

Reuse this client’s base URL, headers, and HTTP backend with a different extension.

impl<Ext> Client<Ext, Client>

where Ext: Provider, Ext::Builder: ProviderBuilder + Default,

builder() is anchored on Client<Ext, reqwest::Client> purely as an inference hook so that provider::Client::builder() resolves without a H annotation. The returned builder itself has H = Missing, accurately reflecting that no backend has been chosen yet; the eventual Client produced by build() may end up with any HTTP backend depending on whether ClientBuilder::http_client was called.

pub fn builder() -> ClientBuilder<Ext::Builder, Missing, Missing>

Start constructing a provider client.

impl<Ext, H> Client<Ext, H>

where Ext: Provider,

pub fn post<S>(&self, path: S) -> Result<Builder>

where S: AsRef<str>,

Build a provider-customized POST request for a regular HTTP endpoint.

pub fn post_sse<S>(&self, path: S) -> Result<Builder>

where S: AsRef<str>,

Build a provider-customized POST request for an SSE endpoint.

pub fn get_sse<S>(&self, path: S) -> Result<Builder>

where S: AsRef<str>,

Build a provider-customized GET request for an SSE endpoint.

pub fn get<S>(&self, path: S) -> Result<Builder>

where S: AsRef<str>,

Build a provider-customized GET request for a regular HTTP endpoint.

impl<H> Client<ChatGPTExt, H>

where H: HttpClientExt + Clone + Debug + Default + WasmCompatSend + WasmCompatSync + 'static,

pub async fn authorize(&self) -> Result<(), AuthError>

impl<T> Client<CohereExt, T>

where T: HttpClientExt + Clone + WasmCompatSend + WasmCompatSync + 'static,

pub fn embeddings<D: Embed>( &self, model: impl Into<String>, input_type: &str, ) -> EmbeddingsBuilder<EmbeddingModel<T>, D>

pub fn embedding_model( &self, model: impl Into<String>, input_type: &str, ) -> EmbeddingModel<T>

Note: default embedding dimension of 0 will be used if model is not known. If this is the case, it’s better to use function embedding_model_with_ndims

pub fn embedding_model_with_ndims( &self, model: impl Into<String>, input_type: &str, ndims: usize, ) -> EmbeddingModel<T>

Create an embedding model with the given name and the number of dimensions in the embedding generated by the model.

impl<H> Client<CopilotExt, H>

where H: HttpClientExt + Clone + Debug + Default + WasmCompatSend + WasmCompatSync + 'static,

pub async fn authorize(&self) -> Result<(), AuthError>

impl<H> Client<GeminiExt, H>

pub fn interactions_api(self) -> InteractionsClient<H>

Create an Interactions API client from this GenerateContent client.

impl<H> Client<GeminiInteractionsExt, H>

pub fn generate_content_api(self) -> Client<H>

Create a GenerateContent API client from this Interactions client.

impl<T> Client<GeminiInteractionsExt, T>

where T: HttpClientExt + Clone + Debug + Default + 'static,

pub async fn create_interaction( &self, request: CreateInteractionRequest, ) -> Result<Interaction, CompletionError>

Create a new interaction and return the raw response payload.

pub async fn get_interaction( &self, interaction_id: impl AsRef<str>, ) -> Result<Interaction, CompletionError>

Fetch an interaction by ID (useful for polling background tasks).

pub async fn stream_interaction_events( &self, request: CreateInteractionRequest, ) -> Result<InteractionEventStream, CompletionError>

Start an interaction and stream raw SSE events.

pub async fn stream_interaction_events_by_id( &self, interaction_id: impl AsRef<str>, last_event_id: Option<&str>, ) -> Result<InteractionEventStream, CompletionError>

Resume an interaction stream by ID and optional last event ID.

impl Client<LlamafileExt>

pub fn from_url(base_url: &str) -> ProviderClientResult<Self>

Create a client pointing at the given llamafile base URL (e.g. http://localhost:8080).

impl<T> Client<MiraExt, T>

where T: HttpClientExt + 'static,

pub async fn list_models(&self) -> Result<Vec<String>, MiraError>

List available models

impl<H> Client<OpenAIResponsesExt, H>

where H: HttpClientExt + Clone + Debug + Default + WasmCompatSend + WasmCompatSync + 'static,

pub fn with_system_instructions_placement( self, placement: SystemInstructionsPlacement, ) -> Self

Sets where Rig system instructions are placed in Responses requests for every completion model created from this client. Models capture the placement when they are created, so models built before this call are unaffected. See SystemInstructionsPlacement for when each placement applies.

pub fn with_system_instructions_as_messages(self) -> Self

Sends Rig system instructions as system messages in input instead of as top-level Responses API instructions for every completion model created from this client. Models built before this call are unaffected.

OpenAI’s Responses API supports instructions, and Rig uses it by default. Use this compatibility fallback for OpenAI-compatible providers that reject or ignore top-level instructions.

pub fn completions_api(self) -> CompletionsClient<H>

Create a Completions API client from this Responses API client. Useful for switching to the traditional Chat Completions API.

impl Client<OpenAIResponsesExt>

pub fn responses_websocket_builder( &self, model: impl Into<String>, ) -> ResponsesWebSocketSessionBuilder

Available on crate feature websocket and non-target_family=wasm only.

WebSocket mode currently uses a native tokio-tungstenite transport and does not reuse custom HttpClientExt backends, so this API is only exposed for the default reqwest::Client transport.

pub async fn responses_websocket( &self, model: impl Into<String>, ) -> Result<ResponsesWebSocketSession, CompletionError>

Available on crate feature websocket and non-target_family=wasm only.

This API is OpenAI-specific and only available on non-wasm targets in rig-core.

impl<H> Client<OpenAICompletionsExt, H>

where H: HttpClientExt + Clone + Debug + Default + WasmCompatSend + WasmCompatSync + 'static,

pub fn responses_api(self) -> Client<H>

Create a Responses API client from this Completions API client. Useful for switching to the newer Responses API. A system-instructions placement configured before switching to the Completions API is restored.

Trait Implementations

impl<M, Ext, H> AudioGenerationClient for Client<Ext, H>

where Ext: Capabilities<H, AudioGeneration = Capable<M>>, M: AudioGenerationModel<Client = Self>,

Available on crate feature audio only.

type AudioGenerationModel = M

The AudioGenerationModel used by the Client

fn audio_generation_model( &self, model: impl Into<String>, ) -> Self::AudioGenerationModel

Create an audio generation model with the given name.

impl<Ext: Clone, H: Clone> Clone for Client<Ext, H>

fn clone(&self) -> Client<Ext, H>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M, Ext, H> CompletionClient for Client<Ext, H>

where Ext: Capabilities<H, Completion = Capable<M>>, M: CompletionModel<Client = Self>,

type CompletionModel = M

The type of CompletionModel used by the client.

fn completion_model(&self, model: impl Into<String>) -> Self::CompletionModel

Create a completion model with the given model.

impl<Ext, H> Debug for Client<Ext, H>

where Ext: DebugExt, H: Debug,

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

Formats the value using the given formatter.

impl<M, Ext, H> EmbeddingsClient for Client<Ext, H>

where Ext: Capabilities<H, Embeddings = Capable<M>>, M: EmbeddingModel<Client = Self>,

type EmbeddingModel = M

The type of EmbeddingModel used by the Client

fn embedding_model(&self, model: impl Into<String>) -> Self::EmbeddingModel

Create an embedding model with the given model.

fn embedding_model_with_ndims( &self, model: impl Into<String>, ndims: usize, ) -> Self::EmbeddingModel

Create an embedding model with the given model identifier string and the number of dimensions in the embedding generated by the model. Use this when the provider supports a model whose dimensionality is not known by Rig.

fn embeddings<D: Embed>( &self, model: impl Into<String>, ) -> EmbeddingsBuilder<Self::EmbeddingModel, D>

Create an embedding builder with the given embedding model.

fn embeddings_with_ndims<D: Embed>( &self, model: &str, ndims: usize, ) -> EmbeddingsBuilder<Self::EmbeddingModel, D>

Create an embedding builder with the given name and the number of dimensions in the embedding generated by the model.

impl<Ext, H> HttpClientExt for Client<Ext, H>

where H: HttpClientExt + 'static, Ext: WasmCompatSend + WasmCompatSync + 'static,

fn send<T, U>( &self, req: Request<T>, ) -> impl Future<Output = Result<Response<LazyBody<U>>>> + WasmCompatSend + 'static

where T: Into<Bytes> + WasmCompatSend, U: From<Bytes> + WasmCompatSend + 'static,

Send a HTTP request, get a response back (as bytes). Response must be able to be turned back into Bytes.

fn send_multipart<U>( &self, req: Request<MultipartForm>, ) -> impl Future<Output = Result<Response<LazyBody<U>>>> + WasmCompatSend + 'static

where U: From<Bytes> + WasmCompatSend + 'static,

Send a HTTP request with a multipart body, get a response back (as bytes). Response must be able to be turned back into Bytes (although usually for the response, you will probably want to specify Bytes anyway).

fn send_streaming<T>( &self, req: Request<T>, ) -> impl Future<Output = Result<StreamingResponse>> + WasmCompatSend

where T: Into<Bytes> + WasmCompatSend,

Send a HTTP request, get a streamed response back (as a stream of bytes::Bytes.)

impl<M, Ext, H> ImageGenerationClient for Client<Ext, H>

where Ext: Capabilities<H, ImageGeneration = Capable<M>>, M: ImageGenerationModel<Client = Self>,

Available on crate feature image only.

type ImageGenerationModel = M

The ImageGenerationModel used by the Client

fn image_generation_model( &self, model: impl Into<String>, ) -> Self::ImageGenerationModel

Create an image generation model with the given name.

fn custom_image_generation_model( &self, model: impl Into<String>, ) -> Self::ImageGenerationModel

Create an image generation model with the given name.

impl<M, Ext, H> ModelListingClient for Client<Ext, H>

where Ext: Capabilities<H, ModelListing = Capable<M>> + Clone, M: ModelLister<H, Client = Self> + WasmCompatSend + WasmCompatSync + Clone + 'static, H: WasmCompatSend + WasmCompatSync + Clone,

fn list_models( &self, ) -> impl Future<Output = Result<ModelList, ModelListingError>> + WasmCompatSend

List all available models from the provider.

impl<M, Ext, H> RerankingClient for Client<Ext, H>

where Ext: Capabilities<H, Rerank = Capable<M>>, M: RerankModel<Client = Self>,

type RerankModel = M

The type of RerankModel used by the Client.

fn rerank_model(&self, model: impl Into<String>) -> Self::RerankModel

Create a reranking model with the given model identifier.

impl<M, Ext, H> TranscriptionClient for Client<Ext, H>

where Ext: Capabilities<H, Transcription = Capable<M>>, M: TranscriptionModel<Client = Self> + WasmCompatSend,

type TranscriptionModel = M

The type of TranscriptionModel used by the Client

fn transcription_model( &self, model: impl Into<String>, ) -> Self::TranscriptionModel

Create a transcription model with the given name.

impl<Ext, H> VerifyClient for Client<Ext, H>

where H: HttpClientExt, Ext: DebugExt + Provider + WasmCompatSync,

async fn verify(&self) -> Result<(), VerifyError>

Verify the configuration.