rust: address responses API review feedback

- Make responses_client/responses_types modules private; expose only the re-exported public surface (matching audio_client/chat_client/etc).

- Introduce ResponseCreateOptions for per-call overrides so callers no longer need to materialize a full ResponseCreateRequest; ResponseCreateRequest stays as the wire-serialized request body.

- Move SSE parser tests inline into responses_client.rs so they exercise parse_sse_stream directly instead of duplicating the framing logic in tests/unit.

- Skip vision_image_base64 only when FOUNDRY_VISION_MODEL_ID is unset; when set, surface real failures so regressions are caught.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: MaanavD

sdk/rust/examples/responses.rs

@@ -107,27 +107,11 @@ async fn main() -> Result<()> {
         .await?;
     println!("Turn 1: {}", first.output_text());
 
-    let follow_up_opts = foundry_local_sdk::ResponseCreateRequest {
-        model: model.info().id.clone(),
-        input: ResponseInput::Text("What is my favourite number?".into()),
+    let follow_up_opts = foundry_local_sdk::ResponseCreateOptions {
         previous_response_id: Some(first.id.clone()),
-        instructions: None,
-        tools: None,
-        tool_choice: None,
-        stream: None,
         store: Some(true),
         temperature: Some(0.0),
-        top_p: None,
-        max_output_tokens: None,
-        frequency_penalty: None,
-        presence_penalty: None,
-        seed: None,
-        truncation: None,
-        parallel_tool_calls: None,
-        metadata: None,
-        user: None,
-        reasoning: None,
-        text: None,
+        ..Default::default()
     };
 
     let second = client
@@ -155,27 +139,12 @@ async fn main() -> Result<()> {
         strict: None,
     };
 
-    let tool_opts = foundry_local_sdk::ResponseCreateRequest {
-        model: model.info().id.clone(),
-        input: ResponseInput::Text("What is 123 + 456? Use the add tool.".into()),
+    let tool_opts = foundry_local_sdk::ResponseCreateOptions {
         tools: Some(vec![add_tool]),
         tool_choice: Some(json!("required")),
-        instructions: None,
-        previous_response_id: None,
-        stream: None,
         store: Some(true),
         temperature: Some(0.0),
-        top_p: None,
-        max_output_tokens: None,
-        frequency_penalty: None,
-        presence_penalty: None,
-        seed: None,
-        truncation: None,
-        parallel_tool_calls: None,
-        metadata: None,
-        user: None,
-        reasoning: None,
-        text: None,
+        ..Default::default()
     };
 
     let tool_response = client
@@ -208,27 +177,11 @@ async fn main() -> Result<()> {
             status: None,
         }]);
 
-        let final_opts = foundry_local_sdk::ResponseCreateRequest {
-            model: model.info().id.clone(),
-            input: result_input.clone(),
+        let final_opts = foundry_local_sdk::ResponseCreateOptions {
             previous_response_id: Some(tool_response.id.clone()),
-            instructions: None,
-            tools: None,
-            tool_choice: None,
-            stream: None,
             store: Some(true),
             temperature: Some(0.0),
-            top_p: None,
-            max_output_tokens: None,
-            frequency_penalty: None,
-            presence_penalty: None,
-            seed: None,
-            truncation: None,
-            parallel_tool_calls: None,
-            metadata: None,
-            user: None,
-            reasoning: None,
-            text: None,
+            ..Default::default()
         };
 
         let final_response = client.create(result_input, Some(final_opts)).await?;

sdk/rust/src/foundry_local_manager.rs

@@ -13,7 +13,7 @@ use crate::configuration::{Configuration, FoundryLocalConfig, Logger};
 use crate::detail::core_interop::CoreInterop;
 use crate::detail::ModelLoadManager;
 use crate::error::{FoundryLocalError, Result};
-use crate::openai::responses_client::ResponsesClient;
+use crate::openai::ResponsesClient;
 use crate::types::{EpDownloadResult, EpInfo};
 
 /// Global singleton holder — only stores a successfully initialised manager.

sdk/rust/src/lib.rs

@@ -48,8 +48,8 @@ pub use async_openai::types::chat::{
 pub use crate::openai::{
     Annotation, DeleteResponseResult, FunctionToolDefinition, IncompleteDetails,
     InputItemsListResponse, InputTokensDetails, ListResponsesOptions, ListResponsesResult, LogProb,
-    MessageContent, OutputTokensDetails, ReasoningConfig, ResponseCreateRequest, ResponseError,
-    ResponseInput, ResponseItem, ResponseObject, ResponseUsage, ResponsesClient,
-    ResponsesClientSettings, ResponsesContentPart, SseStream, StreamingEvent, TextConfig,
-    TextFormat,
+    MessageContent, OutputTokensDetails, ReasoningConfig, ResponseCreateOptions,
+    ResponseCreateRequest, ResponseError, ResponseInput, ResponseItem, ResponseObject,
+    ResponseUsage, ResponsesClient, ResponsesClientSettings, ResponsesContentPart, SseStream,
+    StreamingEvent, TextConfig, TextFormat,
 };

sdk/rust/src/openai/mod.rs

@@ -3,8 +3,8 @@ mod chat_client;
 mod embedding_client;
 mod json_stream;
 mod live_audio_client;
-pub mod responses_client;
-pub mod responses_types;
+mod responses_client;
+mod responses_types;
 
 pub use self::audio_client::{
     AudioClient, AudioClientSettings, AudioTranscriptionResponse, AudioTranscriptionStream,
@@ -22,6 +22,6 @@ pub use self::responses_types::{
     Annotation, ContentPart as ResponsesContentPart, DeleteResponseResult, FunctionToolDefinition,
     IncompleteDetails, InputItemsListResponse, InputTokensDetails, ListResponsesOptions,
     ListResponsesResult, LogProb, MessageContent, OutputTokensDetails, ReasoningConfig,
-    ResponseCreateRequest, ResponseError, ResponseInput, ResponseItem, ResponseObject,
-    ResponseUsage, StreamingEvent, TextConfig, TextFormat,
+    ResponseCreateOptions, ResponseCreateRequest, ResponseError, ResponseInput, ResponseItem,
+    ResponseObject, ResponseUsage, StreamingEvent, TextConfig, TextFormat,
 };

sdk/rust/src/openai/responses_client.rs

@@ -15,8 +15,8 @@ use crate::error::{FoundryLocalError, Result};
 
 use super::responses_types::{
     DeleteResponseResult, FunctionToolDefinition, InputItemsListResponse, ListResponsesResult,
-    ReasoningConfig, ResponseCreateRequest, ResponseInput, ResponseObject, StreamingEvent,
-    TextConfig,
+    ReasoningConfig, ResponseCreateOptions, ResponseCreateRequest, ResponseInput, ResponseObject,
+    StreamingEvent, TextConfig,
 };
 
 // ============================================================================
@@ -159,7 +159,7 @@ impl ResponsesClient {
     pub async fn create(
         &self,
         input: ResponseInput,
-        options: Option<ResponseCreateRequest>,
+        options: Option<ResponseCreateOptions>,
     ) -> Result<ResponseObject> {
         self.validate_input(&input)?;
         if let Some(ref opts) = options {
@@ -193,7 +193,7 @@ impl ResponsesClient {
     pub async fn create_streaming(
         &self,
         input: ResponseInput,
-        options: Option<ResponseCreateRequest>,
+        options: Option<ResponseCreateOptions>,
     ) -> Result<SseStream> {
         self.validate_input(&input)?;
         if let Some(ref opts) = options {
@@ -340,13 +340,13 @@ impl ResponsesClient {
     fn build_request(
         &self,
         input: ResponseInput,
-        options: Option<ResponseCreateRequest>,
+        options: Option<ResponseCreateOptions>,
         stream: bool,
     ) -> Result<ResponseCreateRequest> {
         // Determine model: options override self.model_id
         let model = options
             .as_ref()
-            .map(|o| o.model.clone())
+            .and_then(|o| o.model.clone())
             .filter(|m| !m.trim().is_empty())
             .or_else(|| self.model_id.clone())
             .ok_or_else(|| FoundryLocalError::Validation {
@@ -383,11 +383,9 @@ impl ResponsesClient {
 
         // Apply per-call overrides
         if let Some(opts) = options {
-            if !opts.model.trim().is_empty() {
-                req.model = opts.model;
+            if let Some(m) = opts.model.filter(|m| !m.trim().is_empty()) {
+                req.model = m;
             }
-            // Only override input if the caller passed an options object with explicit input;
-            // in practice options.input will always be overwritten by the positional `input`.
             if let Some(v) = opts.instructions {
                 req.instructions = Some(v);
             }
@@ -635,3 +633,90 @@ where
         }
     }
 }
+
+// ============================================================================
+// Inline tests
+// ============================================================================
+//
+// These tests live alongside `parse_sse_stream` so they exercise the real
+// implementation rather than reimplementing SSE framing in an external test
+// crate. Anything that only depends on public APIs lives in `tests/unit/`.
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use async_stream::stream;
+
+    /// Drive `parse_sse_stream` from a hand-constructed byte stream and collect
+    /// its yielded events.
+    async fn collect_events(chunks: Vec<&'static str>) -> Vec<StreamingEvent> {
+        let byte_stream = stream! {
+            for chunk in chunks {
+                yield Ok::<Bytes, reqwest::Error>(Bytes::from_static(chunk.as_bytes()));
+            }
+        };
+
+        let parsed = parse_sse_stream(byte_stream);
+        let mut parsed = std::pin::pin!(parsed);
+
+        let mut events = Vec::new();
+        use tokio_stream::StreamExt as _;
+        while let Some(event) = parsed.next().await {
+            events.push(event.expect("SSE event failed to parse"));
+        }
+        events
+    }
+
+    #[tokio::test]
+    async fn parses_complete_event_block() {
+        let payload = "data: {\"type\":\"response.output_text.delta\",\"item_id\":\"i1\",\
+            \"output_index\":0,\"content_index\":0,\"delta\":\"Hi\",\"sequence_number\":1}\n\n\
+            data: [DONE]\n\n";
+
+        let events = collect_events(vec![payload]).await;
+        assert_eq!(events.len(), 1);
+        assert!(matches!(
+            events[0],
+            StreamingEvent::OutputTextDelta { ref delta, .. } if delta == "Hi"
+        ));
+    }
+
+    #[tokio::test]
+    async fn done_signal_terminates_stream() {
+        let payload = "data: [DONE]\n\n\
+            data: {\"type\":\"response.output_text.delta\",\"item_id\":\"i1\",\
+            \"output_index\":0,\"content_index\":0,\"delta\":\"after-done\",\
+            \"sequence_number\":2}\n\n";
+
+        let events = collect_events(vec![payload]).await;
+        assert!(events.is_empty(), "events after [DONE] must be ignored");
+    }
+
+    #[tokio::test]
+    async fn handles_event_split_across_chunks() {
+        // Split a single SSE block across two byte chunks to make sure the
+        // parser buffers correctly.
+        let part1 = "data: {\"type\":\"response.output_text.delta\",\
+            \"item_id\":\"i1\",\"output_index\":0,\"content_index\":0,";
+        let part2 = "\"delta\":\"split\",\"sequence_number\":3}\n\ndata: [DONE]\n\n";
+
+        let events = collect_events(vec![part1, part2]).await;
+        assert_eq!(events.len(), 1);
+        assert!(matches!(
+            events[0],
+            StreamingEvent::OutputTextDelta { ref delta, .. } if delta == "split"
+        ));
+    }
+
+    #[tokio::test]
+    async fn skips_event_lines_and_blank_blocks() {
+        let payload = "event: response.output_text.delta\n\
+            data: {\"type\":\"response.output_text.delta\",\"item_id\":\"i1\",\
+            \"output_index\":0,\"content_index\":0,\"delta\":\"ok\",\"sequence_number\":4}\n\n\
+            \n\n\
+            data: [DONE]\n\n";
+
+        let events = collect_events(vec![payload]).await;
+        assert_eq!(events.len(), 1);
+    }
+}

sdk/rust/src/openai/responses_types.rs

@@ -279,6 +279,40 @@ pub struct ResponseCreateRequest {
     pub text: Option<TextConfig>,
 }
 
+/// Per-call overrides for [`ResponsesClient::create`] and
+/// [`ResponsesClient::create_streaming`].
+///
+/// Every field is optional — the client merges these on top of
+/// [`ResponsesClientSettings`] and the constructor-supplied model. Unlike
+/// [`ResponseCreateRequest`] (the wire-serialised request body), this type is
+/// intended purely as caller-friendly input and never needs to be fully
+/// populated.
+///
+/// [`ResponsesClient::create`]: crate::ResponsesClient::create
+/// [`ResponsesClient::create_streaming`]: crate::ResponsesClient::create_streaming
+/// [`ResponsesClientSettings`]: crate::ResponsesClientSettings
+#[derive(Debug, Clone, Default)]
+pub struct ResponseCreateOptions {
+    pub model: Option<String>,
+    pub instructions: Option<String>,
+    pub previous_response_id: Option<String>,
+    pub tools: Option<Vec<FunctionToolDefinition>>,
+    pub tool_choice: Option<Value>,
+    pub store: Option<bool>,
+    pub temperature: Option<f32>,
+    pub top_p: Option<f32>,
+    pub max_output_tokens: Option<u32>,
+    pub frequency_penalty: Option<f32>,
+    pub presence_penalty: Option<f32>,
+    pub seed: Option<u32>,
+    pub truncation: Option<String>,
+    pub parallel_tool_calls: Option<bool>,
+    pub metadata: Option<HashMap<String, String>>,
+    pub user: Option<String>,
+    pub reasoning: Option<ReasoningConfig>,
+    pub text: Option<TextConfig>,
+}
+
 // ============================================================================
 // Response Object
 // ============================================================================