feat: add conversations api (#460)

* conversations API

* convversations example

* update to types

* update to example

* explicit ConversationItem

* move conversation inside responses

* update examples/conversations

* update example

Author: 64bit

async-openai/README.md

@@ -28,6 +28,7 @@
   - [x] Batch
   - [x] Chat
   - [x] Completions (Legacy)
+  - [x] Conversations
   - [x] Embeddings
   - [x] Files
   - [x] Fine-Tuning

async-openai/src/client.rs

@@ -13,8 +13,9 @@ use crate::{
     image::Images,
     moderation::Moderations,
     traits::AsyncTryFrom,
-    Assistants, Audio, AuditLogs, Batches, Chat, Completions, Embeddings, FineTuning, Invites,
-    Models, Projects, Responses, Threads, Uploads, Users, VectorStores, Videos,
+    Assistants, Audio, AuditLogs, Batches, Chat, Completions, Conversations, Embeddings,
+    FineTuning, Invites, Models, Projects, Responses, Threads, Uploads, Users, VectorStores,
+    Videos,
 };
 
 #[derive(Debug, Clone, Default)]
@@ -172,6 +173,11 @@ impl<C: Config> Client<C> {
         Responses::new(self)
     }
 
+    /// To call [Conversations] group related APIs using this client.
+    pub fn conversations(&self) -> Conversations<'_, C> {
+        Conversations::new(self)
+    }
+
     pub fn config(&self) -> &C {
         &self.config
     }

async-openai/src/config.rs

@@ -136,7 +136,7 @@ impl Config for OpenAIConfig {
 
         // hack for Assistants APIs
         // Calls to the Assistants API require that you pass a Beta header
-        headers.insert(OPENAI_BETA_HEADER, "assistants=v2".parse().unwrap());
+        // headers.insert(OPENAI_BETA_HEADER, "assistants=v2".parse().unwrap());
 
         headers
     }

async-openai/src/conversation_items.rs

@@ -0,0 +1,76 @@
+use serde::Serialize;
+
+use crate::{
+    config::Config,
+    error::OpenAIError,
+    types::responses::{
+        ConversationItem, ConversationItemList, ConversationResource,
+        CreateConversationItemsRequest,
+    },
+    Client,
+};
+
+/// Conversation items represent items within a conversation.
+pub struct ConversationItems<'c, C: Config> {
+    client: &'c Client<C>,
+    pub conversation_id: String,
+}
+
+impl<'c, C: Config> ConversationItems<'c, C> {
+    pub fn new(client: &'c Client<C>, conversation_id: &str) -> Self {
+        Self {
+            client,
+            conversation_id: conversation_id.into(),
+        }
+    }
+
+    /// Create items in a conversation.
+    #[crate::byot(T0 = serde::Serialize, R = serde::de::DeserializeOwned)]
+    pub async fn create(
+        &self,
+        request: CreateConversationItemsRequest,
+    ) -> Result<ConversationItemList, OpenAIError> {
+        self.client
+            .post(
+                &format!("/conversations/{}/items", &self.conversation_id),
+                request,
+            )
+            .await
+    }
+
+    /// List all items for a conversation.
+    #[crate::byot(T0 = serde::Serialize, R = serde::de::DeserializeOwned)]
+    pub async fn list<Q>(&self, query: &Q) -> Result<ConversationItemList, OpenAIError>
+    where
+        Q: Serialize + ?Sized,
+    {
+        self.client
+            .get_with_query(
+                &format!("/conversations/{}/items", &self.conversation_id),
+                &query,
+            )
+            .await
+    }
+
+    /// Retrieve an item from a conversation.
+    #[crate::byot(T0 = std::fmt::Display, R = serde::de::DeserializeOwned)]
+    pub async fn retrieve(&self, item_id: &str) -> Result<ConversationItem, OpenAIError> {
+        self.client
+            .get(&format!(
+                "/conversations/{}/items/{item_id}",
+                &self.conversation_id
+            ))
+            .await
+    }
+
+    /// Delete an item from a conversation.
+    #[crate::byot(T0 = std::fmt::Display, R = serde::de::DeserializeOwned)]
+    pub async fn delete(&self, item_id: &str) -> Result<ConversationResource, OpenAIError> {
+        self.client
+            .delete(&format!(
+                "/conversations/{}/items/{item_id}",
+                &self.conversation_id
+            ))
+            .await
+    }
+}

async-openai/src/conversations.rs

@@ -0,0 +1,68 @@
+use crate::{
+    config::Config,
+    conversation_items::ConversationItems,
+    error::OpenAIError,
+    types::responses::{
+        ConversationResource, CreateConversationRequest, DeleteConversationResponse,
+        UpdateConversationRequest,
+    },
+    Client,
+};
+
+pub struct Conversations<'c, C: Config> {
+    client: &'c Client<C>,
+}
+
+impl<'c, C: Config> Conversations<'c, C> {
+    pub fn new(client: &'c Client<C>) -> Self {
+        Self { client }
+    }
+
+    /// [ConversationItems] API group
+    pub fn items(&self, conversation_id: &str) -> ConversationItems<'_, C> {
+        ConversationItems::new(self.client, conversation_id)
+    }
+
+    /// Create a conversation.
+    #[crate::byot(T0 = serde::Serialize, R = serde::de::DeserializeOwned)]
+    pub async fn create(
+        &self,
+        request: CreateConversationRequest,
+    ) -> Result<ConversationResource, OpenAIError> {
+        self.client.post("/conversations", request).await
+    }
+
+    /// Retrieves a conversation.
+    #[crate::byot(T0 = std::fmt::Display, R = serde::de::DeserializeOwned)]
+    pub async fn retrieve(
+        &self,
+        conversation_id: &str,
+    ) -> Result<ConversationResource, OpenAIError> {
+        self.client
+            .get(&format!("/conversations/{conversation_id}"))
+            .await
+    }
+
+    /// Delete a conversation. Items in the conversation will not be deleted.
+    #[crate::byot(T0 = std::fmt::Display, R = serde::de::DeserializeOwned)]
+    pub async fn delete(
+        &self,
+        conversation_id: &str,
+    ) -> Result<DeleteConversationResponse, OpenAIError> {
+        self.client
+            .delete(&format!("/conversations/{conversation_id}"))
+            .await
+    }
+
+    /// Update a conversation.
+    #[crate::byot(T0 = std::fmt::Display, T1 = serde::Serialize, R = serde::de::DeserializeOwned)]
+    pub async fn update(
+        &self,
+        conversation_id: &str,
+        request: UpdateConversationRequest,
+    ) -> Result<ConversationResource, OpenAIError> {
+        self.client
+            .post(&format!("/conversations/{conversation_id}"), request)
+            .await
+    }
+}

async-openai/src/lib.rs

@@ -148,6 +148,8 @@ mod chat;
 mod client;
 mod completion;
 pub mod config;
+mod conversation_items;
+mod conversations;
 mod download;
 mod embedding;
 pub mod error;
@@ -183,6 +185,8 @@ pub use batches::Batches;
 pub use chat::Chat;
 pub use client::Client;
 pub use completion::Completions;
+pub use conversation_items::ConversationItems;
+pub use conversations::Conversations;
 pub use embedding::Embeddings;
 pub use file::Files;
 pub use fine_tuning::FineTuning;

async-openai/src/types/common.rs

@@ -1,4 +1,4 @@
-use std::path::PathBuf;
+use std::{collections::HashMap, path::PathBuf};
 
 use bytes::Bytes;
 use serde::{Deserialize, Serialize};
@@ -16,3 +16,19 @@ pub enum OrganizationRole {
     Owner,
     Reader,
 }
+
+/// Set of 16 key-value pairs that can be attached to an object.
+/// This can be useful for storing additional information about the
+/// object in a structured format, and querying for objects via API
+/// or the dashboard. Keys are strings with a maximum length of 64
+/// characters. Values are strings with a maximum length of 512
+/// characters.
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Default)]
+#[serde(transparent)]
+pub struct Metadata(HashMap<String, String>);
+
+impl From<HashMap<String, String>> for Metadata {
+    fn from(value: HashMap<String, String>) -> Self {
+        Self(value)
+    }
+}