feat: responses & crate ergonomics + bug fixes (64bit#485)

* from traits impls

* updated examples/responses to be simplified

* updates

* more from traits

* updated images-and-vision example

* further from traits

* add responses-structured-outputs example

* add streaming example

* responses stream event ergonomics: event_type

* updated responses function to include streaming example

* handle StreamEnded gracefully

* update example now that StreamEnded is handled gracefully

* fix

* fix: publish false

* remove use of deprecated field types

* remove examples using deprecated types/fields

* responses refactor

* fix coversation example

* refactor impls

* move warpper types impls in its own file

* refactor

* image impls

* impls and forms for each type mods

* create sdk.rs which add SDK like functionality on types

* event types for realtime events

* update example to use event_type()

* Event type for assistant stream events

(cherry picked from commit f6886c2)

Author: 64bit

async-openai/src/impls.rs

@@ -0,0 +1,133 @@
+use crate::{
+    admin_api_keys::AdminAPIKeys,
+    assistants::Assistants,
+    audio::Audio,
+    audit_logs::AuditLogs,
+    batches::Batches,
+    certificates::Certificates,
+    chat::Chat,
+    chatkit::{Chatkit, ChatkitSessions, ChatkitThreads},
+    completion::Completions,
+    container_files::ContainerFiles,
+    containers::Containers,
+    conversation_items::ConversationItems,
+    conversations::Conversations,
+    embedding::Embeddings,
+    eval_run_output_items::EvalRunOutputItems,
+    eval_runs::EvalRuns,
+    evals::Evals,
+    file::Files,
+    fine_tuning::FineTuning,
+    group_roles::GroupRoles,
+    group_users::GroupUsers,
+    groups::Groups,
+    image::Images,
+    invites::Invites,
+    messages::Messages,
+    model::Models,
+    moderation::Moderations,
+    project_api_keys::ProjectAPIKeys,
+    project_certificates::ProjectCertificates,
+    project_group_roles::ProjectGroupRoles,
+    project_groups::ProjectGroups,
+    project_rate_limits::ProjectRateLimits,
+    project_roles::ProjectRoles,
+    project_service_accounts::ProjectServiceAccounts,
+    project_user_roles::ProjectUserRoles,
+    project_users::ProjectUsers,
+    projects::Projects,
+    responses::Responses,
+    roles::Roles,
+    runs::Runs,
+    speech::Speech,
+    steps::Steps,
+    threads::Threads,
+    transcriptions::Transcriptions,
+    translations::Translations,
+    uploads::Uploads,
+    usage::Usage,
+    user_roles::UserRoles,
+    users::Users,
+    vector_store_file_batches::VectorStoreFileBatches,
+    vector_store_files::VectorStoreFiles,
+    vector_stores::VectorStores,
+    video::Videos,
+};
+
+// request builder impls macro
+
+/// Macro to implement `RequestOptionsBuilder` for wrapper types containing `RequestOptions`
+macro_rules! impl_request_options_builder {
+    ($type:ident) => {
+        impl<'c, C: crate::config::Config> crate::traits::RequestOptionsBuilder for $type<'c, C> {
+            fn options_mut(&mut self) -> &mut crate::RequestOptions {
+                &mut self.request_options
+            }
+
+            fn options(&self) -> &crate::RequestOptions {
+                &self.request_options
+            }
+        }
+    };
+}
+
+#[cfg(feature = "realtime")]
+use crate::Realtime;
+
+impl_request_options_builder!(AdminAPIKeys);
+impl_request_options_builder!(Assistants);
+impl_request_options_builder!(Audio);
+impl_request_options_builder!(AuditLogs);
+impl_request_options_builder!(Batches);
+impl_request_options_builder!(Certificates);
+impl_request_options_builder!(Chat);
+impl_request_options_builder!(Chatkit);
+impl_request_options_builder!(ChatkitSessions);
+impl_request_options_builder!(ChatkitThreads);
+impl_request_options_builder!(Completions);
+impl_request_options_builder!(ContainerFiles);
+impl_request_options_builder!(Containers);
+impl_request_options_builder!(ConversationItems);
+impl_request_options_builder!(Conversations);
+impl_request_options_builder!(Embeddings);
+impl_request_options_builder!(Evals);
+impl_request_options_builder!(EvalRunOutputItems);
+impl_request_options_builder!(EvalRuns);
+impl_request_options_builder!(Files);
+impl_request_options_builder!(FineTuning);
+impl_request_options_builder!(GroupRoles);
+impl_request_options_builder!(GroupUsers);
+impl_request_options_builder!(Groups);
+impl_request_options_builder!(Images);
+impl_request_options_builder!(Invites);
+impl_request_options_builder!(Messages);
+impl_request_options_builder!(Models);
+impl_request_options_builder!(Moderations);
+impl_request_options_builder!(Projects);
+impl_request_options_builder!(ProjectGroupRoles);
+impl_request_options_builder!(ProjectGroups);
+impl_request_options_builder!(ProjectRoles);
+impl_request_options_builder!(ProjectUserRoles);
+impl_request_options_builder!(ProjectUsers);
+impl_request_options_builder!(ProjectServiceAccounts);
+impl_request_options_builder!(ProjectAPIKeys);
+impl_request_options_builder!(ProjectRateLimits);
+impl_request_options_builder!(ProjectCertificates);
+impl_request_options_builder!(Roles);
+#[cfg(feature = "realtime")]
+impl_request_options_builder!(Realtime);
+impl_request_options_builder!(Responses);
+impl_request_options_builder!(Runs);
+impl_request_options_builder!(Speech);
+impl_request_options_builder!(Steps);
+impl_request_options_builder!(Threads);
+impl_request_options_builder!(Transcriptions);
+impl_request_options_builder!(Translations);
+impl_request_options_builder!(Uploads);
+impl_request_options_builder!(Usage);
+impl_request_options_builder!(UserRoles);
+impl_request_options_builder!(Users);
+impl_request_options_builder!(VectorStoreFileBatches);
+impl_request_options_builder!(VectorStoreFiles);
+impl_request_options_builder!(VectorStores);
+impl_request_options_builder!(Videos);

async-openai/src/lib.rs

@@ -168,6 +168,7 @@ mod group_roles;
 mod group_users;
 mod groups;
 mod image;
+mod impls;
 mod invites;
 mod messages;
 mod model;

async-openai/src/types/assistants/assistant_stream.rs

@@ -2,7 +2,7 @@ use serde::Deserialize;
 
 use crate::client::OpenAIEventStream;
 use crate::error::{ApiError, OpenAIError, StreamError, map_deserialization_error};
-
+use crate::traits::EventType;
 use crate::types::assistants::{
     MessageDeltaObject, MessageObject, RunObject, RunStepDeltaObject, RunStepObject, ThreadObject,
 };
@@ -209,3 +209,35 @@ impl TryFrom<eventsource_stream::Event> for AssistantStreamEvent {
         }
     }
 }
+
+impl EventType for AssistantStreamEvent {
+    fn event_type(&self) -> &'static str {
+        match self {
+            AssistantStreamEvent::ThreadCreated(_) => "thread.created",
+            AssistantStreamEvent::ThreadRunCreated(_) => "thread.run.created",
+            AssistantStreamEvent::ThreadRunQueued(_) => "thread.run.queued",
+            AssistantStreamEvent::ThreadRunInProgress(_) => "thread.run.in_progress",
+            AssistantStreamEvent::ThreadRunRequiresAction(_) => "thread.run.requires_action",
+            AssistantStreamEvent::ThreadRunCompleted(_) => "thread.run.completed",
+            AssistantStreamEvent::ThreadRunIncomplete(_) => "thread.run.incomplete",
+            AssistantStreamEvent::ThreadRunFailed(_) => "thread.run.failed",
+            AssistantStreamEvent::ThreadRunCancelling(_) => "thread.run.cancelling",
+            AssistantStreamEvent::ThreadRunCancelled(_) => "thread.run.cancelled",
+            AssistantStreamEvent::ThreadRunExpired(_) => "thread.run.expired",
+            AssistantStreamEvent::ThreadRunStepCreated(_) => "thread.run.step.created",
+            AssistantStreamEvent::ThreadRunStepInProgress(_) => "thread.run.step.in_progress",
+            AssistantStreamEvent::ThreadRunStepDelta(_) => "thread.run.step.delta",
+            AssistantStreamEvent::ThreadRunStepCompleted(_) => "thread.run.step.completed",
+            AssistantStreamEvent::ThreadRunStepFailed(_) => "thread.run.step.failed",
+            AssistantStreamEvent::ThreadRunStepCancelled(_) => "thread.run.step.cancelled",
+            AssistantStreamEvent::ThreadRunStepExpired(_) => "thread.run.step.expired",
+            AssistantStreamEvent::ThreadMessageCreated(_) => "thread.message.created",
+            AssistantStreamEvent::ThreadMessageInProgress(_) => "thread.message.in_progress",
+            AssistantStreamEvent::ThreadMessageDelta(_) => "thread.message.delta",
+            AssistantStreamEvent::ThreadMessageCompleted(_) => "thread.message.completed",
+            AssistantStreamEvent::ThreadMessageIncomplete(_) => "thread.message.incomplete",
+            AssistantStreamEvent::ErrorEvent(_) => "error",
+            AssistantStreamEvent::Done(_) => "done",
+        }
+    }
+}

async-openai/src/types/assistants/impls.rs

@@ -0,0 +1,19 @@
+use crate::types::assistants::CreateMessageRequestContent;
+
+impl From<String> for CreateMessageRequestContent {
+    fn from(value: String) -> Self {
+        Self::Content(value)
+    }
+}
+
+impl From<&str> for CreateMessageRequestContent {
+    fn from(value: &str) -> Self {
+        Self::Content(value.to_string())
+    }
+}
+
+impl Default for CreateMessageRequestContent {
+    fn default() -> Self {
+        Self::Content("".into())
+    }
+}

async-openai/src/types/assistants/mod.rs

@@ -2,6 +2,7 @@ mod api;
 mod assistant;
 mod assistant_impls;
 mod assistant_stream;
+mod impls;
 mod message;
 mod run;
 mod step;

async-openai/src/types/audio/form.rs

@@ -0,0 +1,105 @@
+use crate::{
+    error::OpenAIError,
+    traits::AsyncTryFrom,
+    types::audio::{
+        CreateTranscriptionRequest, CreateTranslationRequest, TranscriptionChunkingStrategy,
+    },
+    util::create_file_part,
+};
+
+impl AsyncTryFrom<CreateTranscriptionRequest> for reqwest::multipart::Form {
+    type Error = OpenAIError;
+
+    async fn try_from(request: CreateTranscriptionRequest) -> Result<Self, Self::Error> {
+        let audio_part = create_file_part(request.file.source).await?;
+
+        let mut form = reqwest::multipart::Form::new()
+            .part("file", audio_part)
+            .text("model", request.model);
+
+        if let Some(language) = request.language {
+            form = form.text("language", language);
+        }
+
+        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())
+        }
+
+        if let Some(include) = request.include {
+            for inc in include {
+                form = form.text("include[]", inc.to_string());
+            }
+        }
+
+        if let Some(timestamp_granularities) = request.timestamp_granularities {
+            for tg in timestamp_granularities {
+                form = form.text("timestamp_granularities[]", tg.to_string());
+            }
+        }
+
+        if let Some(stream) = request.stream {
+            form = form.text("stream", stream.to_string());
+        }
+
+        if let Some(chunking_strategy) = request.chunking_strategy {
+            match chunking_strategy {
+                TranscriptionChunkingStrategy::Auto => {
+                    form = form.text("chunking_strategy", "auto");
+                }
+                TranscriptionChunkingStrategy::ServerVad(vad_config) => {
+                    form = form.text(
+                        "chunking_strategy",
+                        serde_json::to_string(&vad_config).unwrap().to_string(),
+                    );
+                }
+            }
+        }
+
+        if let Some(known_speaker_names) = request.known_speaker_names {
+            for kn in known_speaker_names {
+                form = form.text("known_speaker_names[]", kn.to_string());
+            }
+        }
+
+        if let Some(known_speaker_references) = request.known_speaker_references {
+            for kn in known_speaker_references {
+                form = form.text("known_speaker_references[]", kn.to_string());
+            }
+        }
+
+        Ok(form)
+    }
+}
+
+impl AsyncTryFrom<CreateTranslationRequest> for reqwest::multipart::Form {
+    type Error = OpenAIError;
+
+    async fn try_from(request: CreateTranslationRequest) -> Result<Self, Self::Error> {
+        let audio_part = create_file_part(request.file.source).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())
+        }
+        Ok(form)
+    }
+}

async-openai/src/types/audio/impls.rs

@@ -0,0 +1,63 @@
+use std::fmt::Display;
+
+use crate::types::audio::{
+    AudioResponseFormat, TimestampGranularity, TranscriptionInclude, TranslationResponseFormat,
+};
+
+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",
+                AudioResponseFormat::DiarizedJson => "diarized_json",
+            }
+        )
+    }
+}
+
+impl Display for TranslationResponseFormat {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                TranslationResponseFormat::Json => "json",
+                TranslationResponseFormat::Srt => "srt",
+                TranslationResponseFormat::Text => "text",
+                TranslationResponseFormat::VerboseJson => "verbose_json",
+                TranslationResponseFormat::Vtt => "vtt",
+            }
+        )
+    }
+}
+
+impl Display for TimestampGranularity {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                TimestampGranularity::Word => "word",
+                TimestampGranularity::Segment => "segment",
+            }
+        )
+    }
+}
+
+impl Display for TranscriptionInclude {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                TranscriptionInclude::Logprobs => "logprobs",
+            }
+        )
+    }
+}

async-openai/src/types/audio/mod.rs

@@ -1,4 +1,7 @@
 mod audio_types;
+mod form;
+mod impls;
+mod sdk;
 mod stream;
 
 pub use audio_types::*;