Struct AsyncChatCompletion 

pub struct AsyncChatCompletion<N, M, S = StreamOff>
where
    N: ModelName + AsyncChat,
    (N, M): Bounded,
    ChatBody<N, M>: Serialize,
    S: StreamState,
{
    pub key: String,
    /* private fields */
}

Fields

key: String

Implementations

impl<N, M> AsyncChatCompletion<N, M, StreamOff>

where N: ModelName + AsyncChat, (N, M): Bounded, ChatBody<N, M>: Serialize,

pub fn new(model: N, messages: M, key: String) -> Self

pub fn body_mut(&mut self) -> &mut ChatBody<N, M>

pub fn add_messages(self, messages: M) -> Self

pub fn with_request_id(self, request_id: impl Into<String>) -> Self

pub fn with_do_sample(self, do_sample: bool) -> Self

pub fn with_stream(self, stream: bool) -> Self

👎Deprecated: Use enable_stream()/disable_stream() for compile-time guarantees

pub fn with_tool_stream(self, tool_stream: bool) -> Self

where N: ToolStreamEnable,

pub fn with_temperature(self, temperature: f32) -> Self

pub fn with_top_p(self, top_p: f32) -> Self

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

pub fn add_tool(self, tool: Tools) -> Self

pub fn add_tools(self, tools: Vec<Tools>) -> Self

pub fn with_user_id(self, user_id: impl Into<String>) -> Self

pub fn with_stop(self, stop: String) -> Self

pub fn with_thinking(self, thinking: ThinkingType) -> Self

where N: ThinkEnable,

pub fn enable_stream(self) -> AsyncChatCompletion<N, M, StreamOn>

pub fn disable_stream(self) -> AsyncChatCompletion<N, M, StreamOff>

pub fn validate(&self) -> Result<()>

Validate request parameters for non-stream async chat (StreamOff)

pub async fn send(&self) -> Result<ChatCompletionResponse>

where N: Serialize, M: Serialize,

Send the request and parse typed response. Automatically runs validate() before sending.

impl<N, M> AsyncChatCompletion<N, M, StreamOn>

where N: ModelName + AsyncChat, (N, M): Bounded, ChatBody<N, M>: Serialize,

pub fn with_tool_stream(self, tool_stream: bool) -> Self

where N: ToolStreamEnable,

Trait Implementations

impl<N, M, S> HttpClient for AsyncChatCompletion<N, M, S>

where N: ModelName + Serialize + AsyncChat, M: Serialize, (N, M): Bounded, S: StreamState,

type Body = ChatBody<N, M>

The request body type that must implement JSON serialization.

type ApiUrl = &'static str

The API URL type that must be convertible to a string reference.

type ApiKey = String

The API key type that must be convertible to a string reference.

fn api_url(&self) -> &Self::ApiUrl

Returns a reference to the API URL.

fn api_key(&self) -> &Self::ApiKey

Returns a reference to the API key for authentication.

fn body(&self) -> &Self::Body

Returns a reference to the request body.

fn post(&self) -> impl Future<Output = Result<Response>> + Send

Sends a POST request to the API endpoint.

fn get(&self) -> impl Future<Output = Result<Response>> + Send

Sends a GET request to the API endpoint.

impl<N, M> SseStreamable for AsyncChatCompletion<N, M, StreamOn>

where N: ModelName + Serialize + AsyncChat, M: Serialize, (N, M): Bounded,

fn stream_sse_for_each<'a, F>( &'a mut self, on_data: F, ) -> impl Future<Output = Result<()>> + 'a

where F: FnMut(&[u8]) + 'a,

impl<N, M> StreamChatLikeExt for AsyncChatCompletion<N, M, StreamOn>

where N: ModelName + Serialize + AsyncChat, M: Serialize, (N, M): Bounded,

fn stream_for_each<'a, F, Fut>( &'a mut self, on_chunk: F, ) -> impl Future<Output = Result<()>> + 'a

where F: FnMut(ChatStreamResponse) -> Fut + 'a, Fut: Future<Output = Result<()>> + 'a,

Processes streaming responses using an async callback function.

fn to_stream<'a>( &'a mut self, ) -> impl Future<Output = Result<Pin<Box<dyn Stream<Item = Result<ChatStreamResponse>> + Send + 'static>>>> + 'a

Converts the streaming response into a composable Stream.