Add chat gpt api

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "openai-api-rs"
-version = "0.1.1"
+version = "0.1.2"
 edition = "2021"
 authors = ["Dongri Jin <dongrify@gmail.com>"]
 license = "MIT"

README.md

@@ -4,7 +4,7 @@
 Cargo.toml
 ```toml
 [dependencies]
-openai-api-rs = "0.1"
+openai-api-rs = "0.1.2"
 ```
 
 ## Example:
@@ -12,6 +12,30 @@ openai-api-rs = "0.1"
 export OPENAI_API_KEY={YOUR_API}
 ```
 
+### Chat
+```rust
+use openai_api_rs::v1::api::Client;
+use openai_api_rs::v1::chat_completion::{self, ChatCompletionRequest};
+use std::env;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let client = Client::new(env::var("OPENAI_API_KEY").unwrap().to_string());
+    let req = ChatCompletionRequest {
+        model: chat_completion::GPT3_5_TURBO.to_string(),
+        messages: vec![chat_completion::ChatCompletionMessage {
+            role: chat_completion::MessageRole::user,
+            content: String::from("NFTとは？"),
+        }],
+    };
+    let result = client.chat_completion(req).await?;
+    println!("{:?}", result.choices[0].message.content);
+
+    Ok(())
+}
+```
+
+### Completion
 ```rust
 use openai_api_rs::v1::completion::{self, CompletionRequest};
 use openai_api_rs::v1::api::Client;

examples/chat_completion.rs

@@ -0,0 +1,21 @@
+use openai_api_rs::v1::api::Client;
+use openai_api_rs::v1::chat_completion::{self, ChatCompletionRequest};
+use std::env;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let client = Client::new(env::var("OPENAI_API_KEY").unwrap().to_string());
+    let req = ChatCompletionRequest {
+        model: chat_completion::GPT3_5_TURBO.to_string(),
+        messages: vec![chat_completion::ChatCompletionMessage {
+            role: chat_completion::MessageRole::user,
+            content: String::from("NFTとは？"),
+        }],
+    };
+    let result = client.chat_completion(req).await?;
+    println!("{:?}", result.choices[0].message.content);
+
+    Ok(())
+}
+
+// OPENAI_API_KEY=xxxx cargo run --package openai-api-rs --example chat_completion

examples/completion.rs

@@ -1,5 +1,5 @@
-use openai_api_rs::v1::completion::{self, CompletionRequest};
 use openai_api_rs::v1::api::Client;
+use openai_api_rs::v1::completion::{self, CompletionRequest};
 use std::env;
 
 #[tokio::main]
@@ -29,4 +29,4 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     Ok(())
 }
 
-// cargo run --package openai-rs --example completion
+// OPENAI_API_KEY=xxxx cargo run --package openai-api-rs --example completion

src/v1/api.rs

@@ -1,25 +1,15 @@
-
+use crate::v1::chat_completion::{ChatCompletionRequest, ChatCompletionResponse};
 use crate::v1::completion::{CompletionRequest, CompletionResponse};
 use crate::v1::edit::{EditRequest, EditResponse};
-use crate::v1::image::{
-    ImageGenerationRequest,
-    ImageGenerationResponse,
-    ImageEditRequest,
-    ImageEditResponse,
-    ImageVariationRequest,
-    ImageVariationResponse,
-};
 use crate::v1::embedding::{EmbeddingRequest, EmbeddingResponse};
 use crate::v1::file::{
-    FileListResponse,
+    FileDeleteRequest, FileDeleteResponse, FileListResponse, FileRetrieveContentRequest,
-    FileUploadRequest,
+    FileRetrieveContentResponse, FileRetrieveRequest, FileRetrieveResponse, FileUploadRequest,
     FileUploadResponse,
-    FileDeleteRequest,
+};
-    FileDeleteResponse,
+use crate::v1::image::{
-    FileRetrieveRequest,
+    ImageEditRequest, ImageEditResponse, ImageGenerationRequest, ImageGenerationResponse,
-    FileRetrieveResponse,
+    ImageVariationRequest, ImageVariationResponse,
-    FileRetrieveContentRequest,
-    FileRetrieveContentResponse,
 };
 use reqwest::Response;
 
@@ -34,25 +24,30 @@ impl Client {
         Self { api_key }
     }
 
-    pub async fn post<T:serde::ser::Serialize>(&self, path: &str, params: &T) -> Result<Response, Box<dyn std::error::Error>> {
+    pub async fn post<T: serde::ser::Serialize>(
+        &self,
+        path: &str,
+        params: &T,
+    ) -> Result<Response, Box<dyn std::error::Error>> {
         let client = reqwest::Client::new();
-        let url = format!("{}{}", APU_URL_V1, path);
+        let url = format!("{APU_URL_V1}{path}");
         let res = client
             .post(&url)
             .header(reqwest::header::CONTENT_TYPE, "application/json")
-            .header(reqwest::header::AUTHORIZATION, "Bearer ".to_owned() + &self.api_key)
+            .header(
+                reqwest::header::AUTHORIZATION,
+                "Bearer ".to_owned() + &self.api_key,
+            )
             .json(&params)
             .send()
             .await;
         match res {
             Ok(res) => match res.status().is_success() {
                 true => Ok(res),
-                false => {
+                false => Err(Box::new(std::io::Error::new(
-                    Err(Box::new(std::io::Error::new(
                     std::io::ErrorKind::Other,
-                        format!("{}: {}", res.status(), res.text().await.unwrap())
+                    format!("{}: {}", res.status(), res.text().await.unwrap()),
-                    )))
+                ))),
-                },
             },
             Err(e) => Err(Box::new(e)),
         }
@@ -60,22 +55,23 @@ impl Client {
 
     pub async fn get(&self, path: &str) -> Result<Response, Box<dyn std::error::Error>> {
         let client = reqwest::Client::new();
-        let url = format!("{}{}", APU_URL_V1, path);
+        let url = format!("{APU_URL_V1}{path}");
         let res = client
             .get(&url)
             .header(reqwest::header::CONTENT_TYPE, "application/json")
-            .header(reqwest::header::AUTHORIZATION, "Bearer ".to_owned() + &self.api_key)
+            .header(
+                reqwest::header::AUTHORIZATION,
+                "Bearer ".to_owned() + &self.api_key,
+            )
             .send()
             .await;
         match res {
             Ok(res) => match res.status().is_success() {
                 true => Ok(res),
-                false => {
+                false => Err(Box::new(std::io::Error::new(
-                    Err(Box::new(std::io::Error::new(
                     std::io::ErrorKind::Other,
-                        format!("{}: {}", res.status(), res.text().await.unwrap())
+                    format!("{}: {}", res.status(), res.text().await.unwrap()),
-                    )))
+                ))),
-                },
             },
             Err(e) => Err(Box::new(e)),
         }
@@ -83,37 +79,39 @@ impl Client {
 
     pub async fn delete(&self, path: &str) -> Result<Response, Box<dyn std::error::Error>> {
         let client = reqwest::Client::new();
-        let url = format!("{}{}", APU_URL_V1, path);
+        let url = format!("{APU_URL_V1}{path}");
         let res = client
             .delete(&url)
             .header(reqwest::header::CONTENT_TYPE, "application/json")
-            .header(reqwest::header::AUTHORIZATION, "Bearer ".to_owned() + &self.api_key)
+            .header(
+                reqwest::header::AUTHORIZATION,
+                "Bearer ".to_owned() + &self.api_key,
+            )
             .send()
             .await;
         match res {
             Ok(res) => match res.status().is_success() {
                 true => Ok(res),
-                false => {
+                false => Err(Box::new(std::io::Error::new(
-                    Err(Box::new(std::io::Error::new(
                     std::io::ErrorKind::Other,
-                        format!("{}: {}", res.status(), res.text().await.unwrap())
+                    format!("{}: {}", res.status(), res.text().await.unwrap()),
-                    )))
+                ))),
-                },
             },
             Err(e) => Err(Box::new(e)),
         }
     }
 
-    pub async fn completion(&self, req: CompletionRequest) -> Result<CompletionResponse, Box<dyn std::error::Error>> {
+    pub async fn completion(
+        &self,
+        req: CompletionRequest,
+    ) -> Result<CompletionResponse, Box<dyn std::error::Error>> {
         let res = self.post("/completions", &req).await;
         match res {
             Ok(res) => {
                 let r = res.json::<CompletionResponse>().await?;
-                return Ok(r);
+                Ok(r)
-            },
+            }
-            Err(e) => {
+            Err(e) => Err(e),
-                return Err(e);
-            },
         }
     }
 
@@ -122,63 +120,65 @@ impl Client {
         match res {
             Ok(res) => {
                 let r = res.json::<EditResponse>().await?;
-                return Ok(r);
+                Ok(r)
-            },
+            }
-            Err(e) => {
+            Err(e) => Err(e),
-                return Err(e);
-            },
         }
     }
 
-    pub async fn image_generation(&self, req: ImageGenerationRequest) -> Result<ImageGenerationResponse, Box<dyn std::error::Error>> {
+    pub async fn image_generation(
+        &self,
+        req: ImageGenerationRequest,
+    ) -> Result<ImageGenerationResponse, Box<dyn std::error::Error>> {
         let res = self.post("/images/generations", &req).await;
         match res {
             Ok(res) => {
                 let r = res.json::<ImageGenerationResponse>().await?;
-                return Ok(r);
+                Ok(r)
-            },
+            }
-            Err(e) => {
+            Err(e) => Err(e),
-                return Err(e);
-            },
         }
     }
 
-    pub async fn image_edit(&self, req: ImageEditRequest) -> Result<ImageEditResponse, Box<dyn std::error::Error>> {
+    pub async fn image_edit(
+        &self,
+        req: ImageEditRequest,
+    ) -> Result<ImageEditResponse, Box<dyn std::error::Error>> {
         let res = self.post("/images/edits", &req).await;
         match res {
             Ok(res) => {
                 let r = res.json::<ImageEditResponse>().await?;
-                return Ok(r);
+                Ok(r)
-            },
+            }
-            Err(e) => {
+            Err(e) => Err(e),
-                return Err(e);
-            },
         }
     }
 
-    pub async fn image_variation(&self, req: ImageVariationRequest) -> Result<ImageVariationResponse, Box<dyn std::error::Error>> {
+    pub async fn image_variation(
+        &self,
+        req: ImageVariationRequest,
+    ) -> Result<ImageVariationResponse, Box<dyn std::error::Error>> {
         let res = self.post("/images/variations", &req).await;
         match res {
             Ok(res) => {
                 let r = res.json::<ImageVariationResponse>().await?;
-                return Ok(r);
+                Ok(r)
-            },
+            }
-            Err(e) => {
+            Err(e) => Err(e),
-                return Err(e);
-            },
         }
     }
 
-    pub async fn embedding(&self, req: EmbeddingRequest) -> Result<EmbeddingResponse, Box<dyn std::error::Error>> {
+    pub async fn embedding(
+        &self,
+        req: EmbeddingRequest,
+    ) -> Result<EmbeddingResponse, Box<dyn std::error::Error>> {
         let res = self.post("/embeddings", &req).await;
         match res {
             Ok(res) => {
                 let r = res.json::<EmbeddingResponse>().await?;
-                return Ok(r);
+                Ok(r)
-            },
+            }
-            Err(e) => {
+            Err(e) => Err(e),
-                return Err(e);
-            },
         }
     }
 
@@ -187,64 +187,81 @@ impl Client {
         match res {
             Ok(res) => {
                 let r = res.json::<FileListResponse>().await?;
-                return Ok(r);
+                Ok(r)
-            },
+            }
-            Err(e) => {
+            Err(e) => Err(e),
-                return Err(e);
-            },
         }
     }
 
-    pub async fn file_upload(&self, req: FileUploadRequest) -> Result<FileUploadResponse, Box<dyn std::error::Error>> {
+    pub async fn file_upload(
+        &self,
+        req: FileUploadRequest,
+    ) -> Result<FileUploadResponse, Box<dyn std::error::Error>> {
         let res = self.post("/files", &req).await;
         match res {
             Ok(res) => {
                 let r = res.json::<FileUploadResponse>().await?;
-                return Ok(r);
+                Ok(r)
-            },
+            }
-            Err(e) => {
+            Err(e) => Err(e),
-                return Err(e);
-            },
         }
     }
 
-    pub async fn file_delete(&self, req: FileDeleteRequest) -> Result<FileDeleteResponse, Box<dyn std::error::Error>> {
+    pub async fn file_delete(
+        &self,
+        req: FileDeleteRequest,
+    ) -> Result<FileDeleteResponse, Box<dyn std::error::Error>> {
         let res = self.delete(&format!("{}/{}", "/files", req.file_id)).await;
         match res {
             Ok(res) => {
                 let r = res.json::<FileDeleteResponse>().await?;
-                return Ok(r);
+                Ok(r)
-            },
+            }
-            Err(e) => {
+            Err(e) => Err(e),
-                return Err(e);
-            },
         }
     }
 
-    pub async fn file_retrieve(&self, req: FileRetrieveRequest) -> Result<FileRetrieveResponse, Box<dyn std::error::Error>> {
+    pub async fn file_retrieve(
+        &self,
+        req: FileRetrieveRequest,
+    ) -> Result<FileRetrieveResponse, Box<dyn std::error::Error>> {
         let res = self.get(&format!("{}/{}", "/files", req.file_id)).await;
         match res {
             Ok(res) => {
                 let r = res.json::<FileRetrieveResponse>().await?;
-                return Ok(r);
+                Ok(r)
-            },
+            }
-            Err(e) => {
+            Err(e) => Err(e),
-                return Err(e);
-            },
         }
     }
 
-    pub async fn file_retrieve_content(&self, req: FileRetrieveContentRequest) -> Result<FileRetrieveContentResponse, Box<dyn std::error::Error>> {
+    pub async fn file_retrieve_content(
-        let res = self.get(&format!("{}/{}/content", "/files", req.file_id)).await;
+        &self,
+        req: FileRetrieveContentRequest,
+    ) -> Result<FileRetrieveContentResponse, Box<dyn std::error::Error>> {
+        let res = self
+            .get(&format!("{}/{}/content", "/files", req.file_id))
+            .await;
         match res {
             Ok(res) => {
                 let r = res.json::<FileRetrieveContentResponse>().await?;
-                return Ok(r);
+                Ok(r)
-            },
+            }
-            Err(e) => {
+            Err(e) => Err(e),
-                return Err(e);
-            },
         }
     }
 
+    pub async fn chat_completion(
+        &self,
+        req: ChatCompletionRequest,
+    ) -> Result<ChatCompletionResponse, Box<dyn std::error::Error>> {
+        let res = self.post("/chat/completions", &req).await;
+        match res {
+            Ok(res) => {
+                let r = res.json::<ChatCompletionResponse>().await?;
+                Ok(r)
+            }
+            Err(e) => Err(e),
+        }
+    }
 }

src/v1/chat_completion.rs

@@ -0,0 +1,43 @@
+use serde::{Deserialize, Serialize};
+
+use crate::v1::common;
+
+pub const GPT3_5_TURBO: &str = "gpt-3.5-turbo";
+pub const GPT3_5_TURBO_0301: &str = "gpt-3.5-turbo-0301";
+
+#[derive(Debug, Serialize)]
+pub struct ChatCompletionRequest {
+    pub model: String,
+    pub messages: Vec<ChatCompletionMessage>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[allow(non_camel_case_types)]
+pub enum MessageRole {
+    user,
+    system,
+    assistant,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct ChatCompletionMessage {
+    pub role: MessageRole,
+    pub content: String,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct ChatCompletionChoice {
+    pub index: i64,
+    pub message: ChatCompletionMessage,
+    pub finish_reason: String,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct ChatCompletionResponse {
+    pub id: String,
+    pub object: String,
+    pub created: i64,
+    pub model: String,
+    pub choices: Vec<ChatCompletionChoice>,
+    pub usage: common::Usage,
+}

src/v1/common.rs

@@ -1,6 +1,4 @@
-
+use serde::Deserialize;
-use serde::{Deserialize};
-
 
 #[derive(Debug, Deserialize)]
 pub struct Usage {

src/v1/completion.rs

@@ -1,6 +1,6 @@
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
-use std::option::Option;
 use std::collections::HashMap;
+use std::option::Option;
 
 use crate::v1::common;
 

src/v1/edit.rs

@@ -1,4 +1,4 @@
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 use std::option::Option;
 
 use crate::v1::common;

src/v1/embedding.rs

@@ -1,4 +1,4 @@
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 use std::option::Option;
 
 use crate::v1::common;
@@ -19,7 +19,6 @@ pub struct EmbeddingRequest {
     pub user: Option<String>,
 }
 
-
 #[derive(Debug, Deserialize)]
 pub struct EmbeddingResponse {
     pub object: String,

src/v1/file.rs

@@ -1,4 +1,4 @@
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Deserialize)]
 pub struct FileData {
@@ -16,7 +16,6 @@ pub struct FileListResponse {
     pub data: Vec<FileData>,
 }
 
-
 #[derive(Debug, Serialize)]
 pub struct FileUploadRequest {
     pub file: String,
@@ -33,7 +32,6 @@ pub struct FileUploadResponse {
     pub purpose: String,
 }
 
-
 #[derive(Debug, Serialize)]
 pub struct FileDeleteRequest {
     pub file_id: String,
@@ -61,7 +59,6 @@ pub struct FileRetrieveResponse {
     pub purpose: String,
 }
 
-
 #[derive(Debug, Serialize)]
 pub struct FileRetrieveContentRequest {
     pub file_id: String,

src/v1/image.rs

@@ -1,4 +1,4 @@
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 use std::option::Option;
 
 #[derive(Debug, Deserialize)]
@@ -19,7 +19,6 @@ pub struct ImageGenerationRequest {
     pub user: Option<String>,
 }
 
-
 #[derive(Debug, Deserialize)]
 pub struct ImageGenerationResponse {
     pub created: i64,

src/v1/mod.rs

@@ -1,9 +1,10 @@
 pub mod common;
 
+pub mod chat_completion;
 pub mod completion;
 pub mod edit;
-pub mod image;
 pub mod embedding;
 pub mod file;
+pub mod image;
 
 pub mod api;