use crate::client::Client;
use crate::common::Usage;
use crate::error::Error;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Role {
System,
User,
Assistant,
Tool,
Developer,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ChatContent {
Text(String),
Parts(Vec<ContentPart>),
}
impl From<String> for ChatContent {
fn from(s: String) -> Self {
Self::Text(s)
}
}
impl From<&str> for ChatContent {
fn from(s: &str) -> Self {
Self::Text(s.to_owned())
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum ContentPart {
Text {
text: String,
},
ImageUrl {
image_url: ImageUrl,
},
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ImageUrl {
pub url: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub detail: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChatMessage {
pub role: Role,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub content: Option<ChatContent>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub refusal: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub annotations: Option<Vec<Annotation>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tool_call_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tool_calls: Option<Vec<ToolCall>>,
}
impl ChatMessage {
pub fn user(content: impl Into<String>) -> Self {
Self {
role: Role::User,
content: Some(ChatContent::Text(content.into())),
name: None,
refusal: None,
annotations: None,
tool_call_id: None,
tool_calls: None,
}
}
pub fn system(content: impl Into<String>) -> Self {
Self {
role: Role::System,
content: Some(ChatContent::Text(content.into())),
name: None,
refusal: None,
annotations: None,
tool_call_id: None,
tool_calls: None,
}
}
pub fn assistant(content: impl Into<String>) -> Self {
Self {
role: Role::Assistant,
content: Some(ChatContent::Text(content.into())),
name: None,
refusal: None,
annotations: None,
tool_call_id: None,
tool_calls: None,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum Annotation {
UrlCitation {
url_citation: AnnotationUrlCitation,
},
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AnnotationUrlCitation {
pub end_index: u32,
pub start_index: u32,
pub title: String,
pub url: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum ToolCall {
Function {
id: String,
function: FunctionDetails,
},
Custom {
id: String,
custom: CustomDetails,
},
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FunctionDetails {
pub name: String,
pub arguments: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CustomDetails {
pub name: String,
pub input: String,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum FinishReason {
Stop,
Length,
ToolCalls,
ContentFilter,
FunctionCall,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum Stop {
Single(String),
Many(Vec<String>),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum ServiceTier {
Auto,
Default,
Flex,
Scale,
Priority,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[non_exhaustive]
pub struct TopLogprob {
pub token: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub bytes: Option<Vec<i32>>,
pub logprob: f64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[non_exhaustive]
pub struct TokenLogprob {
pub token: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub bytes: Option<Vec<i32>>,
pub logprob: f64,
pub top_logprobs: Vec<TopLogprob>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ChoiceLogprobs {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub content: Option<Vec<TokenLogprob>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub refusal: Option<Vec<TokenLogprob>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[non_exhaustive]
pub struct Choice {
pub index: u32,
pub message: ChatMessage,
pub finish_reason: FinishReason,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub logprobs: Option<ChoiceLogprobs>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ChatCompletion {
#[serde(default)]
pub id: String,
pub choices: Vec<Choice>,
pub created: i64,
pub model: String,
#[serde(default)]
pub object: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub service_tier: Option<ServiceTier>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub system_fingerprint: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub usage: Option<Usage>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub search_results: Option<Vec<serde_json::Value>>,
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct CreateChatCompletion {
pub messages: Vec<ChatMessage>,
pub model: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub frequency_penalty: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub logit_bias: Option<HashMap<String, f64>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub logprobs: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub top_logprobs: Option<u8>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub presence_penalty: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub max_completion_tokens: Option<u32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub n: Option<u32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub response_format: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub seed: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub stop: Option<Stop>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub stream: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub stream_options: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub temperature: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub top_p: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tools: Option<Vec<serde_json::Value>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tool_choice: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub parallel_tool_calls: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub user: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub search: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub search_args: Option<serde_json::Value>,
}
impl CreateChatCompletion {
pub fn new(messages: Vec<ChatMessage>, model: impl Into<String>) -> Self {
Self {
messages,
model: model.into(),
..Self::default()
}
}
#[must_use]
pub fn temperature(mut self, t: f64) -> Self {
self.temperature = Some(t);
self
}
#[must_use]
pub fn top_p(mut self, p: f64) -> Self {
self.top_p = Some(p);
self
}
#[must_use]
pub fn max_completion_tokens(mut self, n: u32) -> Self {
self.max_completion_tokens = Some(n);
self
}
#[must_use]
pub fn seed(mut self, seed: i64) -> Self {
self.seed = Some(seed);
self
}
}
impl Client {
pub async fn chat_completion(
&self,
req: &CreateChatCompletion,
) -> Result<ChatCompletion, Error> {
let mut owned = req.clone();
owned.stream = Some(false);
let url = self.endpoint("/v1/chat/completions")?;
self.post_json(url, &owned).await
}
}