Updates for new openapi spec v1.2 (#44)

* types for Chat API; API group for chat; example for chat completion

* oops: example for chat completion

* types to use for chat streamingc

* chat streaming example

* add comment for reason for different type

* add audio transcribe support

* add audio transcribe example

* audio translate

* add translation example

* update types with updated openapi spec

* update openapi spec yaml file

* more merge conflict resolution

* additional output

* update readme

* update example dependencies

* remove unused duplicate types

* fix

Author: 64bit

async-openai/README.md

@@ -23,7 +23,9 @@
 
 - It's based on [OpenAI OpenAPI spec](https://github.com/openai/openai-openapi)
 - Current features:
-  - [x] Completions (including SSE streaming & Chat)
+  - [x] Audio
+  - [x] Chat (including SSE streaming)
+  - [x] Completions (including SSE streaming)
   - [x] Edits
   - [x] Embeddings
   - [x] Files

async-openai/src/audio.rs

@@ -0,0 +1,73 @@
+use crate::{
+    error::OpenAIError,
+    types::{
+        CreateTranscriptionRequest, CreateTranscriptionResponse, CreateTranslationRequest,
+        CreateTranslationResponse,
+    },
+    util::create_file_part,
+    Client,
+};
+
+/// Turn audio into text
+/// Related guide: [Speech to text](https://platform.openai.com/docs/guides/speech-to-text)
+pub struct Audio<'c> {
+    client: &'c Client,
+}
+
+impl<'c> Audio<'c> {
+    pub fn new(client: &'c Client) -> Self {
+        Self { client }
+    }
+
+    /// Transcribes audio into the input language.
+    pub async fn transcribe(
+        &self,
+        request: CreateTranscriptionRequest,
+    ) -> Result<CreateTranscriptionResponse, OpenAIError> {
+        let audio_part = create_file_part(&request.file.path).await?;
+
+        let mut form = reqwest::multipart::Form::new()
+            .part("file", audio_part)
+            .text("model", request.model);
+
+        if let Some(prompt) = request.prompt {
+            form = form.text("prompt", prompt);
+        }
+
+        if let Some(response_format) = request.response_format {
+            form = form.text("response_format", response_format.to_string())
+        }
+
+        if let Some(temperature) = request.temperature {
+            form = form.text("temperature", temperature.to_string())
+        }
+
+        self.client.post_form("/audio/transcriptions", form).await
+    }
+
+    /// Translates audio into into English.
+    pub async fn translate(
+        &self,
+        request: CreateTranslationRequest,
+    ) -> Result<CreateTranslationResponse, OpenAIError> {
+        let audio_part = create_file_part(&request.file.path).await?;
+
+        let mut form = reqwest::multipart::Form::new()
+            .part("file", audio_part)
+            .text("model", request.model);
+
+        if let Some(prompt) = request.prompt {
+            form = form.text("prompt", prompt);
+        }
+
+        if let Some(response_format) = request.response_format {
+            form = form.text("response_format", response_format.to_string())
+        }
+
+        if let Some(temperature) = request.temperature {
+            form = form.text("temperature", temperature.to_string())
+        }
+
+        self.client.post_form("/audio/translations", form).await
+    }
+}

async-openai/src/chat.rs

@@ -1,11 +1,12 @@
 use crate::{
-    client::Client,
     error::OpenAIError,
-    types::{ChatResponseStream, CreateChatRequest, CreateChatResponse},
+    types::{
+        ChatCompletionResponseStream, CreateChatCompletionRequest, CreateChatCompletionResponse,
+    },
+    Client,
 };
 
-/// Given a series of messages, the model will return one or more predicted
-/// completion messages.
+/// Given a chat conversation, the model will return a chat completion response.
 pub struct Chat<'c> {
     client: &'c Client,
 }
@@ -15,11 +16,11 @@ impl<'c> Chat<'c> {
         Self { client }
     }
 
-    /// Creates a completion for the provided messages and parameters
+    /// Creates a completion for the chat message
     pub async fn create(
         &self,
-        request: CreateChatRequest,
-    ) -> Result<CreateChatResponse, OpenAIError> {
+        request: CreateChatCompletionRequest,
+    ) -> Result<CreateChatCompletionResponse, OpenAIError> {
         if request.stream.is_some() && request.stream.unwrap() {
             return Err(OpenAIError::InvalidArgument(
                 "When stream is true, use Chat::create_stream".into(),
@@ -28,17 +29,15 @@ impl<'c> Chat<'c> {
         self.client.post("/chat/completions", request).await
     }
 
-    /// Creates a completion request for the provided messages and parameters
+    /// Creates a completion for the chat message
     ///
-    /// Stream back partial progress. Tokens will be sent as data-only
-    /// [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#event_stream_format)
-    /// as they become available, with the stream terminated by a data: \[DONE\] message.
+    /// partial message deltas will be sent, like in ChatGPT. Tokens will be sent as data-only [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format) as they become available, with the stream terminated by a `data: [DONE]` message.
     ///
-    /// [ChatResponseStream] is a parsed SSE stream until a \[DONE\] is received from server.
+    /// [ChatCompletionResponseStream] is a parsed SSE stream until a \[DONE\] is received from server.
     pub async fn create_stream(
         &self,
-        mut request: CreateChatRequest,
-    ) -> Result<ChatResponseStream, OpenAIError> {
+        mut request: CreateChatCompletionRequest,
+    ) -> Result<ChatCompletionResponseStream, OpenAIError> {
         if request.stream.is_some() && !request.stream.unwrap() {
             return Err(OpenAIError::InvalidArgument(
                 "When stream is false, use Chat::create".into(),

async-openai/src/client.rs

@@ -6,13 +6,12 @@ use reqwest_eventsource::{Event, EventSource, RequestBuilderExt};
 use serde::{de::DeserializeOwned, Serialize};
 
 use crate::{
-    chat::Chat,
     edit::Edits,
     error::{OpenAIError, WrappedError},
     file::Files,
     image::Images,
     moderation::Moderations,
-    Completions, Embeddings, FineTunes, Models,
+    Audio, Chat, Completions, Embeddings, FineTunes, Models,
 };
 
 #[derive(Debug, Clone)]
@@ -127,6 +126,11 @@ impl Client {
         Embeddings::new(self)
     }
 
+    /// To call [Audio] group related APIs using this client.
+    pub fn audio(&self) -> Audio {
+        Audio::new(self)
+    }
+
     fn headers(&self) -> HeaderMap {
         let mut headers = HeaderMap::new();
         if !self.org_id.is_empty() {

async-openai/src/image.rs

@@ -30,13 +30,16 @@ impl<'c> Images<'c> {
         request: CreateImageEditRequest,
     ) -> Result<ImageResponse, OpenAIError> {
         let image_part = create_file_part(&request.image.path).await?;
-        let mask_part = create_file_part(&request.mask.path).await?;
 
         let mut form = reqwest::multipart::Form::new()
             .part("image", image_part)
-            .part("mask", mask_part)
             .text("prompt", request.prompt);
 
+        if let Some(mask) = request.mask {
+            let mask_part = create_file_part(&mask.path).await?;
+            form = form.part("mask", mask_part);
+        }
+
         if request.n.is_some() {
             form = form.text("n", request.n.unwrap().to_string())
         }

async-openai/src/lib.rs

@@ -48,6 +48,7 @@
 //! ## Examples
 //! For full working examples for all supported features see [examples](https://github.com/64bit/async-openai/tree/main/examples) directory in the repository.
 //!
+mod audio;
 mod chat;
 mod client;
 mod completion;
@@ -63,6 +64,8 @@ mod moderation;
 pub mod types;
 mod util;
 
+pub use audio::Audio;
+pub use chat::Chat;
 pub use client::Client;
 pub use client::API_BASE;
 pub use client::ORGANIZATION_HEADER;

async-openai/src/types/impls.rs

@@ -9,8 +9,8 @@ use crate::{
 };
 
 use super::{
-    EmbeddingInput, FileInput, ImageData, ImageInput, ImageResponse, ImageSize, ModerationInput,
-    Prompt, ResponseFormat, Stop,
+    AudioInput, AudioResponseFormat, EmbeddingInput, FileInput, ImageData, ImageInput,
+    ImageResponse, ImageSize, ModerationInput, Prompt, ResponseFormat, Role, Stop,
 };
 
 macro_rules! impl_from {
@@ -89,6 +89,7 @@ macro_rules! file_path_input {
 
 file_path_input!(ImageInput);
 file_path_input!(FileInput);
+file_path_input!(AudioInput);
 
 impl Display for ImageSize {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -117,6 +118,36 @@ impl Display for ResponseFormat {
     }
 }
 
+impl Display for AudioResponseFormat {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                AudioResponseFormat::Json => "json",
+                AudioResponseFormat::Srt => "srt",
+                AudioResponseFormat::Text => "text",
+                AudioResponseFormat::VerboseJson => "verbose_json",
+                AudioResponseFormat::Vtt => "vtt",
+            }
+        )
+    }
+}
+
+impl Display for Role {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                Role::User => "user",
+                Role::System => "system",
+                Role::Assistant => "assistant",
+            }
+        )
+    }
+}
+
 impl ImageResponse {
     /// Save each image in a dedicated Tokio task and return paths to saved files.
     /// For [ResponseFormat::Url] each file is downloaded in dedicated Tokio task.