Remove ApiPrompt (#11265)

Keep things simple and build a full Responses API request request right
in the model client

codex-rs/codex-api/src/endpoint/responses.rs

@@ -1,14 +1,14 @@
 use crate::auth::AuthProvider;
-use crate::common::Prompt as ApiPrompt;
-use crate::common::Reasoning;
 use crate::common::ResponseStream;
-use crate::common::TextControls;
+use crate::common::ResponsesApiRequest;
 use crate::endpoint::session::EndpointSession;
 use crate::error::ApiError;
 use crate::provider::Provider;
-use crate::requests::ResponsesRequest;
-use crate::requests::ResponsesRequestBuilder;
+use crate::requests::headers::build_conversation_headers;
+use crate::requests::headers::insert_header;
+use crate::requests::headers::subagent_header;
 use crate::requests::responses::Compression;
+use crate::requests::responses::attach_item_ids;
 use crate::sse::spawn_response_stream;
 use crate::telemetry::SseTelemetry;
 use codex_client::HttpTransport;
@@ -21,7 +21,6 @@ use http::Method;
 use serde_json::Value;
 use std::sync::Arc;
 use std::sync::OnceLock;
-use tracing::instrument;
 
 pub struct ResponsesClient<T: HttpTransport, A: AuthProvider> {
     session: EndpointSession<T, A>,
@@ -30,11 +29,6 @@ pub struct ResponsesClient<T: HttpTransport, A: AuthProvider> {
 
 #[derive(Default)]
 pub struct ResponsesOptions {
-    pub reasoning: Option<Reasoning>,
-    pub include: Vec<String>,
-    pub prompt_cache_key: Option<String>,
-    pub text: Option<TextControls>,
-    pub store_override: Option<bool>,
     pub conversation_id: Option<String>,
     pub session_source: Option<SessionSource>,
     pub extra_headers: HeaderMap,
@@ -63,31 +57,10 @@ impl<T: HttpTransport, A: AuthProvider> ResponsesClient<T, A> {
 
     pub async fn stream_request(
         &self,
-        request: ResponsesRequest,
-        turn_state: Option<Arc<OnceLock<String>>>,
-    ) -> Result<ResponseStream, ApiError> {
-        self.stream(
-            request.body,
-            request.headers,
-            request.compression,
-            turn_state,
-        )
-        .await
-    }
-
-    #[instrument(level = "trace", skip_all, err)]
-    pub async fn stream_prompt(
-        &self,
-        model: &str,
-        prompt: &ApiPrompt,
+        request: ResponsesApiRequest,
         options: ResponsesOptions,
     ) -> Result<ResponseStream, ApiError> {
         let ResponsesOptions {
-            reasoning,
-            include,
-            prompt_cache_key,
-            text,
-            store_override,
             conversation_id,
             session_source,
             extra_headers,
@@ -95,21 +68,19 @@ impl<T: HttpTransport, A: AuthProvider> ResponsesClient<T, A> {
             turn_state,
         } = options;
 
-        let request = ResponsesRequestBuilder::new(model, &prompt.instructions, &prompt.input)
-            .tools(&prompt.tools)
-            .parallel_tool_calls(prompt.parallel_tool_calls)
-            .reasoning(reasoning)
-            .include(include)
-            .prompt_cache_key(prompt_cache_key)
-            .text(text)
-            .conversation(conversation_id)
-            .session_source(session_source)
-            .store_override(store_override)
-            .extra_headers(extra_headers)
-            .compression(compression)
-            .build(self.session.provider())?;
+        let mut body = serde_json::to_value(&request)
+            .map_err(|e| ApiError::Stream(format!("failed to encode responses request: {e}")))?;
+        if request.store && self.session.provider().is_azure_responses_endpoint() {
+            attach_item_ids(&mut body, &request.input);
+        }
 
-        self.stream_request(request, turn_state).await
+        let mut headers = extra_headers;
+        headers.extend(build_conversation_headers(conversation_id));
+        if let Some(subagent) = subagent_header(&session_source) {
+            insert_header(&mut headers, "x-openai-subagent", &subagent);
+        }
+
+        self.stream(body, headers, compression, turn_state).await
     }
 
     fn path() -> &'static str {