[codex] Store pending response items directly (#24865)

codex-rs/core/src/codex_thread.rs

@@ -260,7 +260,12 @@ impl CodexThread {
         &self,
         items: Vec<ResponseInputItem>,
     ) -> Result<(), Vec<ResponseInputItem>> {
-        self.codex.session.inject_response_items(items).await
+        let response_items = items.iter().cloned().map(ResponseItem::from).collect();
+        self.codex
+            .session
+            .inject_if_running(response_items)
+            .await
+            .map_err(|_| items)
     }
 
     pub async fn set_app_server_client_info(
@@ -366,58 +371,16 @@ impl CodexThread {
 
     /// Records a user-role session-prefix message without creating a new user turn boundary.
     pub(crate) async fn inject_user_message_without_turn(&self, message: String) {
-        let message = ResponseItem::Message {
+        let item = ResponseItem::Message {
             id: None,
             role: "user".to_string(),
             content: vec![ContentItem::InputText { text: message }],
             phase: None,
         };
-        let pending_item = match pending_message_input_item(&message) {
-            Ok(pending_item) => pending_item,
-            Err(err) => {
-                debug_assert!(false, "session-prefix message append should succeed: {err}");
-                return;
-            }
-        };
-        if self
-            .codex
+        self.codex
             .session
-            .inject_response_items(vec![pending_item])
-            .await
-            .is_err()
-        {
-            let turn_context = self.codex.session.new_default_turn().await;
-            self.codex
-                .session
-                .record_conversation_items(turn_context.as_ref(), &[message])
-                .await;
-        }
-    }
-
-    /// Append a prebuilt message to the thread history without treating it as a user turn.
-    ///
-    /// If the thread already has an active turn, the message is queued as pending input for that
-    /// turn. Otherwise it is queued at session scope and a regular turn is started so the agent
-    /// can consume that pending input through the normal turn pipeline.
-    #[cfg(test)]
-    pub(crate) async fn append_message(&self, message: ResponseItem) -> CodexResult<String> {
-        let submission_id = uuid::Uuid::new_v4().to_string();
-        let pending_item = pending_message_input_item(&message)?;
-        if let Err(items) = self
-            .codex
-            .session
-            .inject_response_items(vec![pending_item])
-            .await
-        {
-            self.codex
-                .session
-                .input_queue
-                .queue_response_items_for_next_turn(items)
-                .await;
-            self.codex.session.maybe_start_turn_for_pending_work().await;
-        }
-
-        Ok(submission_id)
+            .inject_no_new_turn(vec![item], /*current_turn_context*/ None)
+            .await;
     }
 
     /// Append raw Responses API items to the thread's model-visible history.
@@ -437,7 +400,7 @@ impl CodexThread {
         }
         self.codex
             .session
-            .record_conversation_items(turn_context.as_ref(), &items)
+            .inject_no_new_turn(items, Some(turn_context.as_ref()))
             .await;
         self.codex.session.flush_rollout().await?;
         Ok(())
@@ -598,21 +561,3 @@ impl CodexThread {
         Ok(*guard)
     }
 }
-
-fn pending_message_input_item(message: &ResponseItem) -> CodexResult<ResponseInputItem> {
-    match message {
-        ResponseItem::Message {
-            role,
-            content,
-            phase,
-            ..
-        } => Ok(ResponseInputItem::Message {
-            role: role.clone(),
-            content: content.clone(),
-            phase: phase.clone(),
-        }),
-        _ => Err(CodexErr::InvalidRequest(
-            "append_message only supports ResponseItem::Message".to_string(),
-        )),
-    }
-}