feat: responses get/retrieve streaming + ergonomics (64bit#489)

* ergonomics impls

* update exampels

* improve tool-call-stream

* ergo

* udpated example

* add strict example

* allow other voices

* support for GET call to return a stream; use it in Responses GET with stream

* add example to retrive a response with streaming

(cherry picked from commit 74763a0)

Author: 64bit

async-openai/src/client.rs

@@ -473,19 +473,14 @@ impl<C: Config> Client<C> {
     }
 
     /// Make HTTP GET request to receive SSE
-    pub(crate) async fn _get_stream<Q, O>(&self, path: &str, query: &Q) -> OpenAIEventStream<O>
+    pub(crate) async fn get_stream<Q, O>(&self, path: &str, request_options: &RequestOptions,) -> OpenAIEventStream<O>
     where
-        Q: Serialize + ?Sized,
         O: DeserializeOwned + Send + 'static,
     {
-        let event_source = self
-            .http_client
-            .get(self.config.url(path))
-            .query(query)
-            .query(&self.config.query())
-            .headers(self.config.headers())
-            .eventsource()
-            .unwrap();
+        let request_builder =
+            self.build_request_builder(reqwest::Method::GET, path, request_options);
+
+        let event_source = request_builder.eventsource().unwrap();
 
         OpenAIEventStream::new(event_source)
     }

async-openai/src/responses.rs

@@ -81,6 +81,25 @@ impl<'c, C: Config> Responses<'c, C> {
             .await
     }
 
+    /// Retrieves a model response with the given ID with streaming.
+    ///
+    /// Response events will be sent as server-sent events as they become available.
+    #[crate::byot(
+        T0 = std::fmt::Display,
+        R = serde::de::DeserializeOwned,
+        stream = "true",
+        where_clause = "R: std::marker::Send + 'static"
+    )]
+    pub async fn retrieve_stream(&self, response_id: &str) -> Result<ResponseStream, OpenAIError> {
+        let mut request_options = self.request_options.clone();
+        request_options.with_query(&[("stream", "true")])?;
+
+        Ok(self
+            .client
+            .get_stream(&format!("/responses/{}", response_id), &request_options)
+            .await)
+    }
+
     /// Deletes a model response with the given ID.
     #[crate::byot(T0 = std::fmt::Display, R = serde::de::DeserializeOwned)]
     pub async fn delete(&self, response_id: &str) -> Result<DeleteResponse, OpenAIError> {

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

@@ -22,6 +22,8 @@ pub enum Voice {
     Sage,
     Shimmer,
     Verse,
+    #[serde(untagged)]
+    Other(String),
 }
 
 #[derive(Debug, Default, Clone, PartialEq)]

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

@@ -1,7 +1,8 @@
 use std::fmt::Display;
 
 use crate::types::chat::{
-    ChatCompletionFunctionCall, ChatCompletionNamedToolChoice,
+    ChatCompletionFunctionCall, ChatCompletionMessageCustomToolCall, ChatCompletionMessageToolCall,
+    ChatCompletionMessageToolCalls, ChatCompletionNamedToolChoice,
     ChatCompletionRequestAssistantMessage, ChatCompletionRequestAssistantMessageContent,
     ChatCompletionRequestDeveloperMessage, ChatCompletionRequestDeveloperMessageContent,
     ChatCompletionRequestFunctionMessage, ChatCompletionRequestMessage,
@@ -10,7 +11,8 @@ use crate::types::chat::{
     ChatCompletionRequestSystemMessageContent, ChatCompletionRequestToolMessage,
     ChatCompletionRequestToolMessageContent, ChatCompletionRequestUserMessage,
     ChatCompletionRequestUserMessageContent, ChatCompletionRequestUserMessageContentPart,
-    FunctionName, ImageUrl, Role,
+    ChatCompletionTool, ChatCompletionTools, CustomToolChatCompletions, FunctionName, ImageUrl,
+    Role,
 };
 
 impl From<ChatCompletionRequestUserMessage> for ChatCompletionRequestMessage {
@@ -332,3 +334,69 @@ impl Display for Role {
         )
     }
 }
+
+impl From<ChatCompletionTool> for Vec<ChatCompletionTools> {
+    fn from(value: ChatCompletionTool) -> Self {
+        vec![ChatCompletionTools::Function(value)]
+    }
+}
+
+impl From<CustomToolChatCompletions> for Vec<ChatCompletionTools> {
+    fn from(value: CustomToolChatCompletions) -> Self {
+        vec![ChatCompletionTools::Custom(value)]
+    }
+}
+
+impl From<ChatCompletionRequestUserMessage> for Vec<ChatCompletionRequestMessage> {
+    fn from(value: ChatCompletionRequestUserMessage) -> Self {
+        vec![value.into()]
+    }
+}
+
+impl From<ChatCompletionRequestSystemMessage> for Vec<ChatCompletionRequestMessage> {
+    fn from(value: ChatCompletionRequestSystemMessage) -> Self {
+        vec![value.into()]
+    }
+}
+
+impl From<ChatCompletionRequestDeveloperMessage> for Vec<ChatCompletionRequestMessage> {
+    fn from(value: ChatCompletionRequestDeveloperMessage) -> Self {
+        vec![value.into()]
+    }
+}
+
+impl From<ChatCompletionRequestAssistantMessage> for Vec<ChatCompletionRequestMessage> {
+    fn from(value: ChatCompletionRequestAssistantMessage) -> Self {
+        vec![value.into()]
+    }
+}
+
+impl From<ChatCompletionRequestFunctionMessage> for Vec<ChatCompletionRequestMessage> {
+    fn from(value: ChatCompletionRequestFunctionMessage) -> Self {
+        vec![value.into()]
+    }
+}
+
+impl From<ChatCompletionRequestToolMessage> for Vec<ChatCompletionRequestMessage> {
+    fn from(value: ChatCompletionRequestToolMessage) -> Self {
+        vec![value.into()]
+    }
+}
+
+impl From<ChatCompletionMessageToolCall> for ChatCompletionMessageToolCalls {
+    fn from(value: ChatCompletionMessageToolCall) -> Self {
+        ChatCompletionMessageToolCalls::Function(value)
+    }
+}
+
+impl From<ChatCompletionMessageCustomToolCall> for ChatCompletionMessageToolCalls {
+    fn from(value: ChatCompletionMessageCustomToolCall) -> Self {
+        ChatCompletionMessageToolCalls::Custom(value)
+    }
+}
+
+impl From<ImageUrl> for ChatCompletionRequestMessageContentPartImage {
+    fn from(value: ImageUrl) -> Self {
+        ChatCompletionRequestMessageContentPartImage { image_url: value }
+    }
+}

async-openai/src/types/realtime/session.rs

@@ -150,6 +150,8 @@ pub enum RealtimeVoice {
     Verse,
     Marin,
     Cedar,
+    #[serde(untagged)]
+    Other(String),
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone)]

examples/responses-retrieve-stream/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "responses-retrive-stream"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[dependencies]
+async-openai = { path = "../../async-openai" }
+tokio = { version = "1.0", features = ["full"] }
+futures = "0.3"
+serde_json = "1.0"
+

examples/responses-retrieve-stream/src/main.rs

@@ -0,0 +1,45 @@
+use async_openai::{
+    types::responses::{CreateResponseArgs, ResponseStreamEvent},
+    Client,
+};
+use futures::StreamExt;
+use std::error::Error;
+use std::io::{stdout, Write};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+    let client = Client::new();
+
+    // First, create a response with background=true and stream=true
+    println!("Creating a respose with background=true and stream=true ...");
+    let create_request = CreateResponseArgs::default()
+        .model("gpt-4.1")
+        .background(true)
+        .stream(true)
+        .input("Write a function in Rust that adds two u32 and returns u64'")
+        .build()?;
+
+    let mut response = client.responses().create_stream(create_request).await?;
+    let mut response_id = None;
+    let mut lock = stdout().lock();
+
+    while let Some(result) = response.next().await {
+        if let Ok(ResponseStreamEvent::ResponseCreated(event)) = result {
+            writeln!(lock, "Response created with ID: {}", event.response.id).unwrap();
+            response_id = Some(event.response.id.clone());
+            break;
+        }
+    }
+
+    if let Some(response_id) = response_id {
+        writeln!(lock, "\nRetrieving {} with streaming...\n", &response_id).unwrap();
+        let mut retrieve_stream = client.responses().retrieve_stream(&response_id).await?;
+        while let Some(result) = retrieve_stream.next().await {
+            if let Ok(ResponseStreamEvent::ResponseOutputTextDelta(delta)) = result {
+                write!(lock, "{}", delta.delta).unwrap();
+            }
+        }
+    }
+
+    Ok(())
+}